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.

9 files changed, 218 insertions, 107 deletions

diff --git a/include/litmus/ce_domain.h b/include/litmus/ce_domain.h
index 373f3f5f78d3..5d5fdf7d1efc 100644
--- a/include/litmus/ce_domain.h
+++ b/include/litmus/ce_domain.h
@@ -8,7 +8,11 @@ void ce_requeue(domain_t*, struct task_struct*);
 struct task_struct* ce_peek_and_take_ready(domain_t*);
 int ce_higher_prio(struct task_struct*, struct task_struct*);
 
+#ifdef CONFIG_MERGE_TIMERS
+typedef void (*ce_timer_callback_t)(struct rt_event*);
+#else
 typedef enum hrtimer_restart (*ce_timer_callback_t)(struct hrtimer*);
+#endif
 
 void ce_domain_init(domain_t*,
                 raw_spinlock_t*,
diff --git a/include/litmus/event_group.h b/include/litmus/event_group.h
index a2e4d4507738..51d9a0a51e85 100644
--- a/include/litmus/event_group.h
+++ b/include/litmus/event_group.h
@@ -45,19 +45,18 @@ struct rt_event {
          * events.
          */
         struct event_list *event_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
- */
-void init_event_group(struct event_group* group, lt_t res, int cpu);
+        /*
+         * Pointer set by add_event() so that we can cancel this event
+         * without knowing what group it is in (don't touch it).
+         */
+        struct event_group *_event_group;
+};
 
 /**
  * add_event() - Add timer to event group.
- * @group       Group with which to merge event
+ * @group       Group with which to merge event. If NULL, use the event
+ *              group of whatever CPU currently executing on.
  * @e           Event to be fired at a specific time
  * @time        Time to fire event
  */
@@ -66,7 +65,7 @@ void add_event(struct event_group* group, struct rt_event* e, lt_t time);
 /**
  * cancel_event() - Remove event from the group.
  */
-void cancel_event(struct event_group *group, struct rt_event*);
+void cancel_event(struct rt_event*);
 
 /**
  * init_event() - Create an event.
@@ -81,4 +80,11 @@ void init_event(struct rt_event* e, int prio, fire_event_t function,
 struct event_list* event_list_alloc(int);
 void event_list_free(struct event_list *el);
 
+/**
+ * get_event_group_for() - Get the event group for a CPU.
+ * @cpu         The CPU to get the event group for. Use NO_CPU to get the
+ *              event group of the CPU that the call is executing on.
+ */
+struct event_group *get_event_group_for(const int cpu);
+
 #endif
diff --git a/include/litmus/sched_mc.h b/include/litmus/sched_mc.h
index 95cc367c8ade..7088c0766db2 100644
--- a/include/litmus/sched_mc.h
+++ b/include/litmus/sched_mc.h
@@ -51,12 +51,12 @@ struct mc_data {
 struct ce_dom_data {
         int cpu;
         struct task_struct *scheduled, *should_schedule;
-        /*
-         * Each CPU needs a mapping of level A ID (integer) to struct pid so
-         * that we can get its task struct.
-         */
+#ifdef CONFIG_MERGE_TIMERS
+        struct rt_event event;
+#else
         struct hrtimer_start_on_info timer_info;
         struct hrtimer timer;
+#endif
 };
 
 /**
@@ -65,7 +65,8 @@ struct ce_dom_data {
  * @linked      Logically running task, ghost or regular
  * @domain      Domain from which to draw tasks
  * @usable      False if a higher criticality task is running
- * @timer       For ghost task budget enforcement
+ * @event       For ghost task budget enforcement (merge timers)
+ * @timer       For ghost task budget enforcement (not merge timers)
  * @node        Used to sort crit_entries by preemptability in global domains
  */
 struct crit_entry {
@@ -105,7 +106,7 @@ unsigned int mc_ce_get_expected_job(const int, const int);
  */
 long mc_ce_admit_task_common(struct task_struct*);
 void mc_ce_task_exit_common(struct task_struct*);
-void mc_ce_timer_callback_common(domain_t*, struct hrtimer*);
+lt_t mc_ce_timer_callback_common(domain_t*);
 void mc_ce_release_at_common(struct task_struct*, lt_t);
 long mc_ce_activate_plugin_common(void);
 long mc_ce_deactivate_plugin_common(void);
diff --git a/litmus/Makefile b/litmus/Makefile
index af8bc7618b95..b6ca7ab66b16 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -16,12 +16,12 @@ obj-y     = sched_plugin.o litmus.o \
             srp.o \
             bheap.o \
             ctrldev.o \
-            domain.o \
-            event_group.o
+            domain.o
 
-# obj-$(CONFIG_PLUGIN_CEDF) += sched_cedf.o
-# obj-$(CONFIG_PLUGIN_PFAIR) += sched_pfair.o
+obj-$(CONFIG_PLUGIN_CEDF) += sched_cedf.o
+obj-$(CONFIG_PLUGIN_PFAIR) += sched_pfair.o
 obj-$(CONFIG_PLUGIN_MC) += sched_mc.o sched_mc_ce.o ce_domain.o
+obj-$(CONFIG_MERGE_TIMERS) += event_group.o
 
 obj-$(CONFIG_FEATHER_TRACE) += ft_event.o ftdev.o
 obj-$(CONFIG_SCHED_TASK_TRACE) += sched_task_trace.o
diff --git a/litmus/ce_domain.c b/litmus/ce_domain.c
index ac6cc14d44f7..54a4a18e01b7 100644
--- a/litmus/ce_domain.c
+++ b/litmus/ce_domain.c
@@ -1,6 +1,7 @@
 #include <linux/pid.h>
 #include <linux/sched.h>
 #include <linux/hrtimer.h>
+#include <linux/slab.h>
 
 #include <litmus/litmus.h>
 #include <litmus/debug_trace.h>
@@ -78,7 +79,12 @@ void ce_domain_init(domain_t *dom,
                         task_prio);
         dom->data = dom_data;
         dom_data->cpu = cpu;
+#ifdef CONFIG_MERGE_TIMERS
+        init_event(&dom_data->event, CRIT_LEVEL_A, ce_timer_callback,
+                        event_list_alloc(GFP_ATOMIC));
+#else
         hrtimer_start_on_info_init(&dom_data->timer_info);
         hrtimer_init(&dom_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
         dom_data->timer.function = ce_timer_callback;
+#endif
 }
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);
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index db92e849f084..fbd91c829619 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -166,7 +166,7 @@ static void reinit_release_heap(rt_domain_t *rt, struct task_struct* t)
 
 #ifdef CONFIG_MERGE_TIMERS
         rh->event.prio = rt->prio;
-        cancel_event(rt->event_group, &rh->event);
+        cancel_event(&rh->event);
 #else
         /* Make sure it is safe to use.  The timer callback could still
          * be executing on another CPU; hrtimer_cancel() will wait
@@ -188,7 +188,11 @@ static void reinit_release_heap(rt_domain_t *rt, struct task_struct* t)
 
 }
 
+#ifdef CONFIG_RELEASE_MASTER
+static void arm_release_timer_on(struct release_heap *rh, int target_cpu)
+#else
 static void arm_release_timer(struct release_heap *rh)
+#endif
 {
 #ifdef CONFIG_MERGE_TIMERS
         add_event(rh->dom->event_group, &rh->event, rh->release_time);
@@ -200,8 +204,7 @@ static void arm_release_timer(struct release_heap *rh)
          */
 
 #ifdef CONFIG_RELEASE_MASTER
-        if (rt->release_master == NO_CPU &&
-            target_cpu == NO_CPU)
+        if (rh->dom->release_master == NO_CPU && target_cpu == NO_CPU)
 #endif
                 __hrtimer_start_range_ns(&rh->timer,
                                          ns_to_ktime(rh->release_time),
@@ -210,7 +213,7 @@ static void arm_release_timer(struct release_heap *rh)
         else
                 hrtimer_start_on(/* target_cpu overrides release master */
                                  (target_cpu != NO_CPU ?
-                                  target_cpu : rt->release_master),
+                                  target_cpu : rh->dom->release_master),
                                  &rh->info, &rh->timer,
                                  ns_to_ktime(rh->release_time),
                                  HRTIMER_MODE_ABS_PINNED);
@@ -278,9 +281,13 @@ static void setup_release(rt_domain_t *_rt)
                  * owner do the arming (which is the "first" task to reference
                  * this release_heap anyway).
                  */
-                if (rh == tsk_rt(t)->rel_heap)
+                if (rh == tsk_rt(t)->rel_heap) {
+#ifdef CONFIG_RELEASE_MASTER
+                        arm_release_timer_on(rh, target_cpu);
+#else
                         arm_release_timer(rh);
-                else
+#endif
+                } else
                         VTRACE_TASK(t, "0x%p is not my timer\n", &rh->timer);
         }
 }
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 7b74958d1f4f..17f84c9eba79 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -27,6 +27,8 @@
 #include <litmus/sched_mc.h>
 #include <litmus/ce_domain.h>
 
+/* XXX TODO Do we ever want to move level-A timers? */
+
 /**
  * struct cpu_entry - State of a CPU for the entire MC system
  * @cpu           CPU id
@@ -34,6 +36,9 @@
  * @linked        Task that should be running / is logically running
  * @lock          For serialization
  * @crit_entries  Array of CPU state per criticality level
+ * @redir         List of redirected work for this CPU.
+ * @redir_lock    Lock for @redir.
+ * @event_group   Event group for timer merging.
  */
 struct cpu_entry {
         int                     cpu;
@@ -45,18 +50,12 @@ struct cpu_entry {
         struct list_head        redir;
         raw_spinlock_t          redir_lock;
 #endif
-#ifdef CONFIG_MERGE_TIMERS
-        struct event_group*     event_group;
-#endif
 };
 
 DEFINE_PER_CPU(struct cpu_entry, cpus);
 #ifdef CONFIG_RELEASE_MASTER
 static int interrupt_cpu;
 #endif
-#ifdef CONFIG_MERGE_TIMERS
-static struct event_group* global_group;
-#endif
 
 #define domain_data(dom)  (container_of(dom, struct domain_data, domain))
 #define is_global(dom)    (domain_data(dom)->heap)
@@ -67,6 +66,7 @@ static struct event_group* global_group;
         (((e)->linked) ? tsk_mc_crit((e)->linked) : NUM_CRIT_LEVELS - 1)
 #define crit_cpu(ce) \
         (container_of((void*)((ce) - (ce)->level), struct cpu_entry, crit_entries))
+#define get_crit_entry_for(cpu, level) (&per_cpu(cpus, cpu).crit_entries[level])
 #define TRACE_ENTRY(e, fmt, args...)                            \
         STRACE("P%d, linked=" TS " " fmt "\n", e->cpu, TA(e->linked), ##args)
 #define TRACE_CRIT_ENTRY(ce, fmt, args...)                      \
@@ -129,7 +129,7 @@ static inline struct crit_entry* lowest_prio_cpu(struct domain *dom)
 static inline void cancel_ghost(struct crit_entry *ce)
 {
 #ifdef CONFIG_MERGE_TIMERS
-        cancel_event(crit_cpu(ce)->event_group, &ce->event);
+        cancel_event(&ce->event);
 #else
         hrtimer_try_to_cancel(&ce->timer);
 #endif
@@ -141,10 +141,10 @@ static inline void cancel_ghost(struct crit_entry *ce)
 static inline void arm_ghost(struct crit_entry *ce, lt_t fire)
 {
 #ifdef CONFIG_MERGE_TIMERS
-        add_event(crit_cpu(ce)->event_group, &ce->event, fire);
+        add_event(get_event_group_for(crit_cpu(ce)->cpu), &ce->event, fire);
 #else
         __hrtimer_start_range_ns(&ce->timer,
-                                 ns_to_ktime(when_to_fire),
+                                 ns_to_ktime(fire),
                                  0 /* delta */,
                                  HRTIMER_MODE_ABS_PINNED,
                                  0 /* no wakeup */);
@@ -270,10 +270,8 @@ static void low_prio_arrival(struct task_struct *task)
         if (!can_requeue(task)) return;
 
 #ifdef  CONFIG_PLUGIN_MC_REDIRECT
-#ifndef CONFIG_PLUGIN_MC_REDIRECT_ALL
         if (!is_global_task(task))
-            goto arrive;
-#endif
+                goto arrive;
         if (smp_processor_id() != interrupt_cpu) {
                 entry = &__get_cpu_var(cpus);
                 raw_spin_lock(&entry->redir_lock);
@@ -284,7 +282,7 @@ static void low_prio_arrival(struct task_struct *task)
         } else
 #endif
         {
-        arrive:
+arrive:
                 job_arrival(task);
         }
 }
@@ -576,19 +574,19 @@ static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
 #endif
 }
 
-static enum hrtimer_restart ce_timer_function(struct hrtimer *timer)
+/*
+ * The MC-CE common timer callback code for merged and non-merged timers.
+ * Returns the next time the timer should fire.
+ */
+static lt_t __ce_timer_function(struct ce_dom_data *ce_data)
 {
-        struct ce_dom_data *ce_data =
-                container_of(timer, struct ce_dom_data, timer);
-        struct crit_entry *ce = &per_cpu(cpus, ce_data->cpu).crit_entries[CRIT_LEVEL_A];
+        struct crit_entry *ce = get_crit_entry_for(ce_data->cpu, CRIT_LEVEL_A);
         struct domain *dom = ce->domain;
         struct task_struct *old_link = NULL;
-        unsigned long flags;
+        lt_t next_timer_abs;
 
         TRACE("MC level-A timer callback for CPU %d\n", ce_data->cpu);
 
-        local_irq_save(flags);
-
         raw_spin_lock(dom->lock);
 
         raw_spin_lock(&crit_cpu(ce)->lock);
@@ -602,7 +600,7 @@ static enum hrtimer_restart ce_timer_function(struct hrtimer *timer)
         }
         raw_spin_unlock(&crit_cpu(ce)->lock);
 
-        mc_ce_timer_callback_common(dom, timer);
+        next_timer_abs = mc_ce_timer_callback_common(dom);
 
         /* job completion will check for preemptions by means of calling job
          * arrival if the task is not blocked */
@@ -615,11 +613,38 @@ static enum hrtimer_restart ce_timer_function(struct hrtimer *timer)
                 raw_spin_unlock(dom->lock);
                 check_for_preempt(dom);
         }
+        return next_timer_abs;
+}
 
+#ifdef CONFIG_MERGE_TIMERS
+static void ce_timer_function(struct rt_event *e)
+{
+        struct ce_dom_data *ce_data =
+                container_of(e, struct ce_dom_data, event);
+        struct event_group *event_group = get_event_group_for(ce_data->cpu);
+        unsigned long flags;
+        lt_t next_timer_abs;
+
+        local_irq_save(flags);
+        next_timer_abs = __ce_timer_function(ce_data);
+        add_event(event_group, e, next_timer_abs);
         local_irq_restore(flags);
+}
+#else /* else to CONFIG_MERGE_TIMERS */
+static enum hrtimer_restart ce_timer_function(struct hrtimer *timer)
+{
+        struct ce_dom_data *ce_data =
+                container_of(timer, struct ce_dom_data, timer);
+        unsigned long flags;
+        lt_t next_timer_abs;
 
+        local_irq_save(flags);
+        next_timer_abs = __ce_timer_function(ce_data);
+        hrtimer_set_expires(timer, ns_to_ktime(next_timer_abs));
+        local_irq_restore(flags);
         return HRTIMER_RESTART;
 }
+#endif /* CONFIG_MERGE_TIMERS */
 
 
 /**
@@ -915,14 +940,6 @@ static rt_domain_t _mc_crit_c_rt;
 struct bheap _mc_heap_c;
 struct bheap_node _mc_nodes_c[NR_CPUS];
 
-#ifdef CONFIG_MERGE_TIMERS
-#ifdef CONFIG_PLUGIN_MC_RELEASE_MASTER
-struct event_group _mc_group;
-#else
-DEFINE_PER_CPU(struct event_group, _mc_groups);
-#endif
-#endif
-
 static long mc_activate_plugin(void)
 {
         struct domain_data *dom_data;
@@ -933,8 +950,14 @@ static long mc_activate_plugin(void)
 
 #ifdef CONFIG_RELEASE_MASTER
         interrupt_cpu = atomic_read(&release_master_cpu);
-        if (interrupt_cpu == NO_CPU)
-                interrupt_cpu = 0;
+#if defined(CONFIG_PLUGIN_MC_REDIRECT) || \
+    (defined(CONFIG_PLUGIN_MC_RELEASE_MASTER) && defined(CONFIG_MERGE_TIMERS))
+        if (NO_CPU == interrupt_cpu) {
+                printk(KERN_ERR "LITMUS-MC: need a release master\n");
+                ret = -EINVAL;
+                goto out;
+        }
+#endif
 #endif
 
         for_each_online_cpu(cpu) {
@@ -1016,20 +1039,30 @@ static void init_global_domain(struct domain_data *dom_data, enum crit_level lev
 }
 
 static inline void init_edf_domain(struct domain *dom, rt_domain_t *rt,
-                                   int timer_cpu, int prio)
+                                   int prio, int is_partitioned, int cpu)
 {
         pd_domain_init(dom, rt, edf_ready_order, NULL,
                        mc_release_jobs, mc_preempt_needed,
                        edf_higher_prio);
-#ifdef CONFIG_PLUGIN_MC_RELEASE_MASTER
-#ifdef CONFIG_MERGE_TIMERS
-        rt->event_group = &_mc_group;
+#if defined(CONFIG_PLUGIN_MC_RELEASE_MASTER) && defined(CONFIG_MERGE_TIMERS)
+        /* All timers are on one CPU and release-master is using the event
+         * merging interface as well. */
+        BUG_ON(NO_CPU == interrupt_cpu);
+        rt->event_group = get_event_group_for(interrupt_cpu);
         rt->prio = prio;
-#else
+#elif defined(CONFIG_PLUGIN_MC_RELEASE_MASTER) && !defined(CONFIG_MERGE_TIMERS)
+        /* Using release master, but not merging timers. */
         rt->release_master = interrupt_cpu;
-#endif
-#elif CONFIG_MERGE_TIMERS
-        rt->event_group = &_mc_groups[timer_cpu];
+#elif !defined(CONFIG_PLUGIN_MC_RELEASE_MASTER) && defined(CONFIG_MERGE_TIMERS)
+        /* Merge the timers, but don't move them to the release master. */
+        if (is_partitioned) {
+                rt->event_group = get_event_group_for(cpu);
+        } else {
+                /* Global timers will be added to the event groups that code is
+                 * executing on when add_event() is called.
+                 */
+                rt->event_group = NULL;
+        }
         rt->prio = prio;
 #endif
 }
@@ -1058,16 +1091,6 @@ static int __init init_mc(void)
                 INIT_LIST_HEAD(&entry->redir);
 #endif
 
-#ifdef CONFIG_MERGE_TIMERS
-#ifdef CONFIG_PLUGIN_MC_RELEASE_MASTER
-                entry->event_group = &_mc_group;
-#else
-                init_event_group(&_mc_groups[cpu],
-                                 CONFIG_MERGE_TIMERS_WINDOW, cpu);
-                entry->event_group = &_mc_groups[cpu];
-#endif
-#endif
-
                 /* CRIT_LEVEL_A */
                 dom_data = &per_cpu(_mc_crit_a, cpu);
                 ce_data = &per_cpu(_mc_crit_a_ce_data, cpu);
@@ -1085,25 +1108,17 @@ static int __init init_mc(void)
                 dom_data = &per_cpu(_mc_crit_b, cpu);
                 rt = &per_cpu(_mc_crit_b_rt, cpu);
                 init_local_domain(entry, dom_data, CRIT_LEVEL_B);
-                init_edf_domain(&dom_data->domain, rt, cpu, CRIT_LEVEL_B);
+                init_edf_domain(&dom_data->domain, rt, CRIT_LEVEL_B, 1, cpu);
                 b_dom_lock = dom_data->domain.lock;
                 raw_spin_lock_init(b_dom_lock);
                 dom_data->domain.name = "LVL-B";
         }
 
-#ifdef CONFIG_MERGE_TIMERS
-#ifdef CONFIG_PLUGIN_MC_RELEASE_MASTER
-        init_event_group(&_mc_group, CONFIG_MERGE_TIMERS_WINDOW, interrupt_cpu);
-        global_group = &_mc_group;
-#else
-        global_group = &_mc_groups[0];
-#endif
-#endif
-
         /* CRIT_LEVEL_C */
         init_global_domain(&_mc_crit_c, CRIT_LEVEL_C,
                            &_mc_heap_c, _mc_nodes_c);
-        init_edf_domain(&_mc_crit_c.domain, &_mc_crit_c_rt, 0, CRIT_LEVEL_C);
+        init_edf_domain(&_mc_crit_c.domain, &_mc_crit_c_rt, CRIT_LEVEL_C,
+                        0, NO_CPU);
         c_dom_lock = _mc_crit_c.domain.lock;
         raw_spin_lock_init(c_dom_lock);
         _mc_crit_c.domain.name = "LVL-C";
diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index 63b0470e1f52..c5066918f282 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -52,6 +52,10 @@ struct ce_pid_entry {
         unsigned int expected_job;
 };
 
+/*
+ * Each CPU needs a mapping of level A ID (integer) to struct pid so that we
+ * can get its task struct.
+ */
 struct ce_pid_table {
         struct ce_pid_entry entries[CONFIG_PLUGIN_MC_LEVEL_A_MAX_TASKS];
         int num_pid_entries;
@@ -434,7 +438,10 @@ void mc_ce_task_exit_common(struct task_struct *ts)
  * Timer stuff
  **********************************************************/
 
-void mc_ce_timer_callback_common(struct domain *dom, struct hrtimer *timer)
+/*
+ * Returns the next absolute time that the timer should fire.
+ */
+lt_t mc_ce_timer_callback_common(struct domain *dom)
 {
         /* relative and absolute times for cycles */
         lt_t now, offset_rel, cycle_start_abs, next_timer_abs;
@@ -455,9 +462,7 @@ void mc_ce_timer_callback_common(struct domain *dom, struct hrtimer *timer)
         cycle_start_abs = now - offset_rel;
         idx = mc_ce_schedule_at(dom, offset_rel);
         pid_entry = get_pid_entry(ce_data->cpu, idx);
-        /* set the timer to fire at the next cycle start */
         next_timer_abs = cycle_start_abs + pid_entry->acc_time;
-        hrtimer_set_expires(timer, ns_to_ktime(next_timer_abs));
 
         STRACE("timer: now: %llu  offset_rel: %llu  cycle_start_abs: %llu  "
                         "next_timer_abs: %llu\n", now, offset_rel,
@@ -495,32 +500,52 @@ void mc_ce_timer_callback_common(struct domain *dom, struct hrtimer *timer)
                 sched_trace_task_release(should_schedule);
                 set_rt_flags(ce_data->should_schedule, RT_F_RUNNING);
         }
+        return next_timer_abs;
 }
 
 /*
  * What to do when a timer fires. The timer should only be armed if the number
  * of PID entries is positive.
  */
+#ifdef CONFIG_MERGE_TIMERS
+static void mc_ce_timer_callback(struct rt_event *e)
+#else
 static enum hrtimer_restart mc_ce_timer_callback(struct hrtimer *timer)
+#endif
 {
         struct ce_dom_data *ce_data;
         unsigned long flags;
         struct domain *dom;
-
+        lt_t next_timer_abs;
+#ifdef CONFIG_MERGE_TIMERS
+        struct event_group *event_group;
+        ce_data = container_of(e, struct ce_dom_data, event);
+        event_group = get_event_group_for(ce_data->cpu);
+#else
         ce_data = container_of(timer, struct ce_dom_data, timer);
+#endif
         dom = get_domain_for(ce_data->cpu);
 
         TRACE("timer callback on CPU %d (before lock)\n", ce_data->cpu);
 
         raw_spin_lock_irqsave(dom->lock, flags);
-        mc_ce_timer_callback_common(dom, timer);
+        next_timer_abs = mc_ce_timer_callback_common(dom);
+
+        /* setup an event or timer for the next release in the CE schedule */
+#ifdef CONFIG_MERGE_TIMERS
+        add_event(event_group, e, next_timer_abs);
+#else
+        hrtimer_set_expires(timer, ns_to_ktime(next_timer_abs));
+#endif
 
         if (ce_data->scheduled != ce_data->should_schedule)
                 preempt_if_preemptable(ce_data->scheduled, ce_data->cpu);
 
         raw_spin_unlock_irqrestore(dom->lock, flags);
 
+#ifndef CONFIG_MERGE_TIMERS
         return HRTIMER_RESTART;
+#endif
 }
 
 /*
@@ -530,7 +555,10 @@ static int cancel_all_timers(void)
 {
         struct ce_dom_data *ce_data;
         struct domain *dom;
-        int cpu, cancel_res, ret = 0;
+        int cpu, ret = 0;
+#ifndef CONFIG_MERGE_TIMERS
+        int cancel_res;
+#endif
 
         TRACE("cancel all timers\n");
 
@@ -538,10 +566,14 @@ static int cancel_all_timers(void)
                 dom = get_domain_for(cpu);
                 ce_data = dom->data;
                 ce_data->should_schedule = NULL;
+#ifdef CONFIG_MERGE_TIMERS
+                cancel_event(&ce_data->event);
+#else
                 cancel_res = hrtimer_cancel(&ce_data->timer);
                 atomic_set(&ce_data->timer_info.state,
                                 HRTIMER_START_ON_INACTIVE);
                 ret = ret || cancel_res; 
+#endif
         }
         return ret;
 }
@@ -570,9 +602,14 @@ static void arm_all_timers(void)
                 for (idx = 0; idx < pid_table->num_pid_entries; idx++) {
                         pid_table->entries[idx].expected_job = 0;
                 }
+#ifdef CONFIG_MERGE_TIMERS
+                TRACE("adding event for CPU %d\n", cpu);
+                add_event(get_event_group_for(cpu), &ce_data->event, start);
+#else
                 TRACE("arming timer for CPU %d\n", cpu);
                 hrtimer_start_on(cpu, &ce_data->timer_info, &ce_data->timer,
                                 ns_to_ktime(start), HRTIMER_MODE_ABS_PINNED);
+#endif
         }
 }