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.

6 files changed, 191 insertions, 91 deletions

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