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