1 files changed, 246 insertions, 156 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index afba6e44716f..7b74958d1f4f 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -22,67 +22,64 @@
 #include <litmus/sched_trace.h>
 #include <litmus/domain.h>
 #include <litmus/bheap.h>
+#include <litmus/event_group.h>
 
 #include <litmus/sched_mc.h>
 #include <litmus/ce_domain.h>
 
 /**
- * cpu_entry_t - State of a CPU for the entire MC system
+ * struct cpu_entry - State of a CPU for the entire MC system
  * @cpu           CPU id
  * @scheduled     Task that is physically running
  * @linked        Task that should be running / is logically running
  * @lock          For serialization
  * @crit_entries  Array of CPU state per criticality level
  */
-typedef struct {
+struct cpu_entry {
         int                     cpu;
         struct task_struct*     scheduled;
         struct task_struct*     linked;
         raw_spinlock_t          lock;
-        crit_entry_t            crit_entries[NUM_CRIT_LEVELS];
+        struct crit_entry       crit_entries[NUM_CRIT_LEVELS];
 #ifdef CONFIG_PLUGIN_MC_REDIRECT
         struct list_head        redir;
         raw_spinlock_t          redir_lock;
 #endif
-} cpu_entry_t;
+#ifdef CONFIG_MERGE_TIMERS
+        struct event_group*     event_group;
+#endif
+};
 
-static cpu_entry_t* cpus[NR_CPUS];
+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, domain_data_t, domain))
+#define domain_data(dom)  (container_of(dom, struct domain_data, domain))
 #define is_global(dom)    (domain_data(dom)->heap)
 #define is_global_task(t) (is_global(get_task_domain(t)))
-#define is_in_list(t)     (tsk_rt(t)->list.next != tsk_rt(t)->list)
 #define can_requeue(t)                                  \
         (!is_global_task(t) || (t)->rt_param.scheduled_on == NO_CPU)
 #define entry_level(e) \
         (((e)->linked) ? tsk_mc_crit((e)->linked) : NUM_CRIT_LEVELS - 1)
 #define crit_cpu(ce) \
-        (container_of((void*)((ce) - (ce)->level), cpu_entry_t, crit_entries))
-/* Useful debug macros */
-#define TS "(%s/%d:%d:%s)"
-#define TA(t) (t) ? (is_ghost(t)) ? "ghost" : t->comm : "NULL", (t) ? t->pid : 1, \
-              (t) ? t->rt_param.job_params.job_no : 1,                  \
-              (t && get_task_domain(t)) ? get_task_domain(t)->name : ""
+        (container_of((void*)((ce) - (ce)->level), struct cpu_entry, crit_entries))
 #define TRACE_ENTRY(e, fmt, args...)                            \
-        TRACE("P%d, linked=" TS " " fmt "\n", \
-              e->cpu, TA(e->linked), ##args)
+        STRACE("P%d, linked=" TS " " fmt "\n", e->cpu, TA(e->linked), ##args)
 #define TRACE_CRIT_ENTRY(ce, fmt, args...)                      \
-        TRACE("%s P%d, linked=" TS " " fmt "\n",                \
+        STRACE("%s P%d, linked=" TS " " fmt "\n",                       \
               (ce)->domain->name, crit_cpu(ce)->cpu, TA((ce)->linked), ##args)
-#undef  TRACE_TASK
-#define TRACE_TASK(t, fmt, args...)                             \
-        TRACE(TS " " fmt "\n", TA(t), ##args)
 
 /*
  * Sort CPUs within a global domain by the domain's priority function.
  */
 static int cpu_lower_prio(struct bheap_node *a, struct bheap_node *b)
 {
-        domain_t *domain;
-        crit_entry_t *first, *second;
+        struct domain *domain;
+        struct crit_entry *first, *second;
         struct task_struct *first_link, *second_link;
 
         first  = a->value;
@@ -104,7 +101,7 @@ static int cpu_lower_prio(struct bheap_node *a, struct bheap_node *b)
  * Return true if the domain has a higher priority ready task. The curr
  * task must belong to the domain.
  */
-noinline int mc_preempt_needed(domain_t *dom, struct task_struct* curr)
+static int mc_preempt_needed(struct domain *dom, struct task_struct* curr)
 {
         struct task_struct *next = dom->peek_ready(dom);
         if (!next || !curr) {
@@ -119,15 +116,43 @@ noinline int mc_preempt_needed(domain_t *dom, struct task_struct* curr)
  * Return next CPU which should preempted or NULL if the domain has no
  * preemptable CPUs.
  */
-static inline crit_entry_t* lowest_prio_cpu(domain_t *dom)
+static inline struct crit_entry* lowest_prio_cpu(struct domain *dom)
 {
         struct bheap *heap = domain_data(dom)->heap;
         struct bheap_node* hn = bheap_peek(cpu_lower_prio, heap);
         return (hn) ? hn->value : NULL;
 }
 
-/**
- * update_ghost_time() - Time accounting for ghost tasks.
+/*
+ * Cancel ghost timer.
+ */
+static inline void cancel_ghost(struct crit_entry *ce)
+{
+#ifdef CONFIG_MERGE_TIMERS
+        cancel_event(crit_cpu(ce)->event_group, &ce->event);
+#else
+        hrtimer_try_to_cancel(&ce->timer);
+#endif
+}
+
+/*
+ * Arm ghost timer. Will merge timers if the option is specified.
+ */
+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);
+#else
+        __hrtimer_start_range_ns(&ce->timer,
+                                 ns_to_ktime(when_to_fire),
+                                 0 /* delta */,
+                                 HRTIMER_MODE_ABS_PINNED,
+                                 0 /* no wakeup */);
+#endif
+}
+
+/*
+ * Time accounting for ghost tasks.
  * Must be called before a decision is made involving the task's budget.
  */
 static void update_ghost_time(struct task_struct *p)
@@ -137,14 +162,14 @@ static void update_ghost_time(struct task_struct *p)
         BUG_ON(!is_ghost(p));
         if (unlikely ((s64)delta < 0)) {
                 delta = 0;
-                TRACE_TASK(p, "WARNING: negative time delta");
+                TRACE_MC_TASK(p, "WARNING: negative time delta");
         }
         if (tsk_mc_data(p)->mc_job.ghost_budget <= delta) {
-                TRACE_TASK(p, "Ghost job could have ended");
+                TRACE_MC_TASK(p, "Ghost job could have ended");
                 tsk_mc_data(p)->mc_job.ghost_budget = 0;
                 p->se.exec_start = clock;
         } else {
-                TRACE_TASK(p, "Ghost job updated, but didn't finish");
+                TRACE_MC_TASK(p, "Ghost job updated, but didn't finish");
                 tsk_mc_data(p)->mc_job.ghost_budget -= delta;
                 p->se.exec_start = clock;
         }
@@ -154,7 +179,7 @@ static void update_ghost_time(struct task_struct *p)
  * link_task_to_crit() - Logically run a task at a criticality level.
  * Caller must hold @ce's domain's lock.
  */
-static void link_task_to_crit(crit_entry_t *ce,
+static void link_task_to_crit(struct crit_entry *ce,
                               struct task_struct *task)
 {
         lt_t when_to_fire;
@@ -168,10 +193,10 @@ static void link_task_to_crit(crit_entry_t *ce,
 
         /* Unlink last task */
         if (ce->linked) {
-                TRACE_TASK(ce->linked, "Unlinking");
+                TRACE_MC_TASK(ce->linked, "Unlinking");
                 ce->linked->rt_param.linked_on = NO_CPU;
                 if (is_ghost(ce->linked)) {
-                        hrtimer_try_to_cancel(&ce->timer);
+                        cancel_ghost(ce);
                         if (tsk_mc_data(ce->linked)->mc_job.ghost_budget > 0) {
                                 /* Job isn't finished, so do accounting */
                                 update_ghost_time(ce->linked);
@@ -192,11 +217,7 @@ static void link_task_to_crit(crit_entry_t *ce,
                         task->se.exec_start = litmus_clock();
                         when_to_fire = task->se.exec_start +
                                 tsk_mc_data(task)->mc_job.ghost_budget;
-                        __hrtimer_start_range_ns(&ce->timer,
-                                                 ns_to_ktime(when_to_fire),
-                                                 0 /* delta */,
-                                                 HRTIMER_MODE_ABS_PINNED,
-                                                 0 /* no wakeup */);
+                        arm_ghost(ce, when_to_fire);
                 }
         }
 
@@ -208,21 +229,23 @@ static void link_task_to_crit(crit_entry_t *ce,
         }
 }
 
-void mc_check_for_preempt(domain_t*);
+static void check_for_preempt(struct domain*);
+
 /**
  * job_arrival() - Called when a task re-enters the system.
  * Caller must hold no locks.
  */
 static void job_arrival(struct task_struct *task)
 {
-        domain_t *dom = get_task_domain(task);
+        struct domain *dom = get_task_domain(task);
 
-        TRACE_TASK(task, "Job arriving");
+        TRACE_MC_TASK(task, "Job arriving");
         BUG_ON(!task);
+
         if (can_requeue(task)) {
                 raw_spin_lock(dom->lock);
                 dom->requeue(dom, task);
-                mc_check_for_preempt(dom);
+                check_for_preempt(dom);
                 raw_spin_unlock(dom->lock);
         } else {
                 /* If a global task is scheduled on one cpu, it CANNOT
@@ -231,7 +254,7 @@ static void job_arrival(struct task_struct *task)
                  * causing the system to crash when the task is scheduled
                  * in two places simultaneously.
                  */
-                TRACE_TASK(task, "Delayed arrival of scheduled task");
+                TRACE_MC_TASK(task, "Delayed arrival of scheduled task");
         }
 }
 
@@ -241,7 +264,7 @@ static void job_arrival(struct task_struct *task)
  */
 static void low_prio_arrival(struct task_struct *task)
 {
-        cpu_entry_t *entry;
+        struct cpu_entry *entry;
 
         /* Race conditions! */
         if (!can_requeue(task)) return;
@@ -252,9 +275,9 @@ static void low_prio_arrival(struct task_struct *task)
             goto arrive;
 #endif
         if (smp_processor_id() != interrupt_cpu) {
-                entry = cpus[smp_processor_id()];
+                entry = &__get_cpu_var(cpus);
                 raw_spin_lock(&entry->redir_lock);
-                TRACE_TASK(task, "Adding to redirect queue");
+                TRACE_MC_TASK(task, "Adding to redirect queue");
                 list_add(&tsk_rt(task)->list, &entry->redir);
                 raw_spin_unlock(&entry->redir_lock);
                 litmus_reschedule(interrupt_cpu);
@@ -273,18 +296,18 @@ static void low_prio_arrival(struct task_struct *task)
 static void fix_global_levels(void)
 {
         int c;
-        cpu_entry_t *e;
+        struct cpu_entry *e;
         struct list_head *pos, *safe;
         struct task_struct *t;
 
-        TRACE("Fixing global levels\n");
+        STRACE("Fixing global levels");
         for_each_online_cpu(c) {
-                e = cpus[c];
+                e = &per_cpu(cpus, c);
                 raw_spin_lock(&e->redir_lock);
                 list_for_each_safe(pos, safe, &e->redir) {
                         t = list_entry(pos, struct task_struct, rt_param.list);
-                        TRACE_TASK(t, "Dequeued redirected job");
-                        BUG_ON(is_queued(t));
+                        BUG_ON(!t);
+                        TRACE_MC_TASK(t, "Dequeued redirected job");
                         list_del_init(pos);
                         job_arrival(t);
                 }
@@ -298,10 +321,10 @@ static void fix_global_levels(void)
  * The task must first have been linked to one of the CPU's crit_entries.
  * Caller must hold the entry lock.
  */
-static void link_task_to_cpu(cpu_entry_t *entry, struct task_struct *task)
+static void link_task_to_cpu(struct cpu_entry *entry, struct task_struct *task)
 {
         int i = entry_level(entry);
-        TRACE_TASK(task, "Linking to P%d", entry->cpu);
+        TRACE_MC_TASK(task, "Linking to P%d", entry->cpu);
         BUG_ON(task && tsk_rt(task)->linked_on != entry->cpu);
         BUG_ON(task && is_ghost(task));
 
@@ -322,10 +345,10 @@ static void link_task_to_cpu(cpu_entry_t *entry, struct task_struct *task)
  *
  * Caller must hold the lock for @dom and @ce's CPU lock.
  */
-static void preempt(domain_t *dom, crit_entry_t *ce)
+static void preempt(struct domain *dom, struct crit_entry *ce)
 {
         struct task_struct *task = dom->take_ready(dom);
-        cpu_entry_t *entry = crit_cpu(ce);
+        struct cpu_entry *entry = crit_cpu(ce);
 
         BUG_ON(!task);
         TRACE_CRIT_ENTRY(ce, "Preempted by " TS, TA(task));
@@ -347,17 +370,25 @@ static void preempt(domain_t *dom, crit_entry_t *ce)
  * This should be called after a new task has been linked to @entry.
  * The caller must hold the @entry->lock, but this method will release it.
  */
-static void update_crit_levels(cpu_entry_t *entry)
+static void update_crit_levels(struct cpu_entry *entry)
 {
-        int i;
-        crit_entry_t *ce;
-        struct task_struct *tasks[NUM_CRIT_LEVELS];
+        int i, global_preempted;
+        struct crit_entry *ce;
+        struct task_struct *readmit[NUM_CRIT_LEVELS];
         enum crit_level level = entry_level(entry);
 
         /* Remove lower priority tasks from the entry */
         for (i = level + 1; i < NUM_CRIT_LEVELS; i++) {
                 ce = &entry->crit_entries[i];
-                tasks[i] = ce->linked;
+
+                global_preempted = entry->scheduled == ce->linked &&
+                        ce->linked && entry->linked &&
+                        !is_ghost(ce->linked) && is_global(ce->domain);
+                /* Do not readmit global tasks which are preempted! These can't
+                 * ever be re-admitted until they are descheduled for reasons
+                 * explained in job_arrival.
+                 */
+                readmit[i] = (!global_preempted) ? ce->linked : NULL;
                 ce->usable = 0;
                 if (ce->linked)
                         link_task_to_crit(ce, NULL);
@@ -368,25 +399,24 @@ static void update_crit_levels(cpu_entry_t *entry)
         /* Re-admit tasks to the system */
         for (i = level + 1; i < NUM_CRIT_LEVELS; i++) {
                 ce = &entry->crit_entries[i];
-                if (tasks[i])
-                        low_prio_arrival(tasks[i]);
+                if (readmit[i])
+                        low_prio_arrival(readmit[i]);
         }
 }
 
 /**
- * mc_check_for_preempt() - Causes a preemption if higher-priority tasks are ready.
+ * check_for_preempt() - Causes a preemption if higher-priority tasks are ready.
  * Caller must hold domain lock.
  * Makes gigantic nasty assumption that there is 1 global criticality level,
  * and it is the last one in each list, so it doesn't call update_crit..
  */
-void mc_check_for_preempt(domain_t *dom)
+static void check_for_preempt(struct domain *dom)
 {
         int preempted = 1;
-        cpu_entry_t *entry;
-        crit_entry_t *ce;
+        struct cpu_entry *entry;
+        struct crit_entry *ce;
 
         if (is_global(dom)) {
-                TRACE("domain: %s is global\n", dom->name);
                 /* Loop until we find a non-preemptable CPU */
                 while ((ce = lowest_prio_cpu(dom)) && preempted) {
                         entry = crit_cpu(ce);
@@ -399,7 +429,6 @@ void mc_check_for_preempt(domain_t *dom)
                         raw_spin_unlock(&entry->lock);
                 }
         } else /* Partitioned */ {
-                TRACE("domain: %s is partitioned\n", dom->name);
                 ce = domain_data(dom)->crit_entry;
                 entry = crit_cpu(ce);
                 raw_spin_lock(&entry->lock);
@@ -407,7 +436,6 @@ void mc_check_for_preempt(domain_t *dom)
                         preempt(dom, ce);
                         update_crit_levels(entry);
                 } else {
-                        TRACE("domain: %s NOT preempting\n", dom->name);
                         raw_spin_unlock(&entry->lock);
                 }
         }
@@ -420,17 +448,17 @@ void mc_check_for_preempt(domain_t *dom)
 static void remove_from_all(struct task_struct* task)
 {
         int update = 0;
-        cpu_entry_t *entry;
-        crit_entry_t *ce;
-        domain_t *dom = get_task_domain(task);
+        struct cpu_entry *entry;
+        struct crit_entry *ce;
+        struct domain *dom = get_task_domain(task);
 
-        TRACE_TASK(task, "Removing from everything");
+        TRACE_MC_TASK(task, "Removing from everything");
         BUG_ON(!task);
 
         raw_spin_lock(dom->lock);
 
         if (task->rt_param.linked_on != NO_CPU) {
-                entry = cpus[task->rt_param.linked_on];
+                entry = &per_cpu(cpus, task->rt_param.linked_on);
                 raw_spin_lock(&entry->lock);
 
                 /* Unlink only if task is still linked post lock */
@@ -469,7 +497,8 @@ static void remove_from_all(struct task_struct* task)
  */
 static void job_completion(struct task_struct *task, int forced)
 {
-        TRACE_TASK(task, "Completed");
+        lt_t now;
+        TRACE_MC_TASK(task, "Completed");
         sched_trace_task_completion(task, forced);
         BUG_ON(!task);
 
@@ -477,9 +506,11 @@ static void job_completion(struct task_struct *task, int forced)
         set_rt_flags(task, RT_F_SLEEP);
         remove_from_all(task);
 
+        now = litmus_clock();
+
         /* If it's not a ghost job, do ghost job conversion */
         if (!is_ghost(task)) {
-                TRACE_TASK(task, "is not a ghost task\n");
+                TRACE_MC_TASK(task, "is not a ghost task");
                 tsk_mc_data(task)->mc_job.ghost_budget = budget_remaining(task);
                 tsk_mc_data(task)->mc_job.is_ghost = 1;
         }
@@ -489,7 +520,7 @@ static void job_completion(struct task_struct *task, int forced)
          * conversion. Revert back to a normal task and complete the period.
          */
         if (tsk_mc_data(task)->mc_job.ghost_budget == 0) {
-                TRACE_TASK(task, "has zero ghost budget\n");
+                TRACE_MC_TASK(task, "has zero ghost budget");
                 tsk_mc_data(task)->mc_job.is_ghost = 0;
                 prepare_for_next_period(task);
                 if (is_released(task, litmus_clock()))
@@ -504,14 +535,22 @@ static void job_completion(struct task_struct *task, int forced)
 /**
  * mc_ghost_exhausted() - Complete logically running ghost task.
  */
+#ifdef CONFIG_MERGE_TIMERS
+static void mc_ghost_exhausted(struct rt_event *e)
+{
+        struct crit_entry *ce = container_of(e, struct crit_entry, event);
+#else
 static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
 {
+        struct crit_entry *ce = container_of(timer, struct crit_entry, timer);
+#endif
+
         unsigned long flags;
         struct task_struct *tmp = NULL;
-        crit_entry_t *ce = container_of(timer, crit_entry_t, timer);
 
         local_irq_save(flags);
-        TRACE_CRIT_ENTRY(ce, "Ghost exhausted firing");
+        TRACE("Ghost exhausted\n");
+        TRACE_CRIT_ENTRY(ce, "Firing here");
 
         /* Due to race conditions, we cannot just set the linked
          * task's budget to 0 as it may no longer be the task
@@ -532,15 +571,17 @@ static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
                 job_completion(tmp, 0);
 
         local_irq_restore(flags);
+#ifndef CONFIG_MERGE_TIMERS
         return HRTIMER_NORESTART;
+#endif
 }
 
 static enum hrtimer_restart ce_timer_function(struct hrtimer *timer)
 {
         struct ce_dom_data *ce_data =
                 container_of(timer, struct ce_dom_data, timer);
-        crit_entry_t *ce = &cpus[ce_data->cpu]->crit_entries[CRIT_LEVEL_A];
-        domain_t *dom = ce->domain;
+        struct crit_entry *ce = &per_cpu(cpus, ce_data->cpu).crit_entries[CRIT_LEVEL_A];
+        struct domain *dom = ce->domain;
         struct task_struct *old_link = NULL;
         unsigned long flags;
 
@@ -566,13 +607,13 @@ static enum hrtimer_restart ce_timer_function(struct hrtimer *timer)
         /* job completion will check for preemptions by means of calling job
          * arrival if the task is not blocked */
         if (NULL != old_link) {
-                TRACE("   old_link " TS " so will call job completion\n", TA(old_link));
+                STRACE("old_link " TS " so will call job completion\n", TA(old_link));
                 raw_spin_unlock(dom->lock);
                 job_completion(old_link, 0);
         } else {
-                TRACE("   old_link was null, so will call check for preempt\n");
+                STRACE("old_link was null, so will call check for preempt\n");
                 raw_spin_unlock(dom->lock);
-                mc_check_for_preempt(dom);
+                check_for_preempt(dom);
         }
 
         local_irq_restore(flags);
@@ -588,12 +629,12 @@ static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 {
         unsigned long flags;
         struct task_struct *first = bheap_peek(rt->order, tasks)->value;
-        domain_t *dom = get_task_domain(first);
+        struct domain *dom = get_task_domain(first);
 
         raw_spin_lock_irqsave(dom->lock, flags);
-        TRACE_TASK(first, "Jobs released");
+        TRACE(TS "Jobs released\n", TA(first));
         __merge_ready(rt, tasks);
-        mc_check_for_preempt(dom);
+        check_for_preempt(dom);
         raw_spin_unlock_irqrestore(dom->lock, flags);
 }
 
@@ -604,7 +645,7 @@ static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 static void mc_task_new(struct task_struct *t, int on_rq, int running)
 {
         unsigned long flags;
-        cpu_entry_t* entry;
+        struct cpu_entry* entry;
         enum crit_level level = tsk_mc_crit(t);
 
         local_irq_save(flags);
@@ -612,9 +653,9 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
 
         /* Assign domain */
         if (level < CRIT_LEVEL_C)
-                entry = cpus[get_partition(t)];
+                entry = &per_cpu(cpus, get_partition(t));
         else
-                entry = cpus[task_cpu(t)];
+                entry = &per_cpu(cpus, task_cpu(t));
         t->rt_param._domain = entry->crit_entries[level].domain;
 
         /* Setup job params */
@@ -644,7 +685,7 @@ static void mc_task_wake_up(struct task_struct *task)
         lt_t now = litmus_clock();
         local_irq_save(flags);
 
-        TRACE_TASK(task, "Wakes up");
+        TRACE(TS " wakes up\n", TA(task));
         if (is_tardy(task, now)) {
                 /* Task missed its last release */
                 release_at(task, now);
@@ -663,7 +704,7 @@ static void mc_task_block(struct task_struct *task)
 {
         unsigned long flags;
         local_irq_save(flags);
-        TRACE_TASK(task, "Block at %llu", litmus_clock());
+        TRACE(TS " blocks\n", TA(task));
         remove_from_all(task);
         local_irq_restore(flags);
 }
@@ -676,11 +717,11 @@ static void mc_task_exit(struct task_struct *task)
         unsigned long flags;
         local_irq_save(flags);
         BUG_ON(!is_realtime(task));
-        TRACE_TASK(task, "RIP");
+        TRACE(TS " RIP\n", TA(task));
 
         remove_from_all(task);
         if (tsk_rt(task)->scheduled_on != NO_CPU) {
-                cpus[tsk_rt(task)->scheduled_on]->scheduled = NULL;
+                per_cpu(cpus, tsk_rt(task)->scheduled_on).scheduled = NULL;
                 tsk_rt(task)->scheduled_on = NO_CPU;
         }
 
@@ -728,9 +769,9 @@ out:
 static struct task_struct* mc_schedule(struct task_struct * prev)
 {
         unsigned long flags;
-        domain_t *dom;
-        crit_entry_t *ce;
-        cpu_entry_t* entry = cpus[smp_processor_id()];
+        struct domain *dom;
+        struct crit_entry *ce;
+        struct cpu_entry* entry = &__get_cpu_var(cpus);
         int i, out_of_time, sleep, preempt, exists, blocks, global, lower;
         struct task_struct *dtask = NULL, *ready_task = NULL, *next = NULL;
 
@@ -742,6 +783,7 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
         BUG_ON(is_realtime(prev) && !entry->scheduled);
 
         /* Determine state */
+        raw_spin_lock(&entry->lock);
         exists      = entry->scheduled != NULL;
         blocks      = exists && !is_running(entry->scheduled);
         out_of_time = exists && budget_enforced(entry->scheduled) &&
@@ -754,24 +796,27 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
 
         if (exists) {
                 entry->scheduled->rt_param.scheduled_on = NO_CPU;
-                TRACE_TASK(prev,
-                           "blocks:%d out_of_time:%d sleep:%d preempt:%d "
-                           "state:%d sig:%d global:%d",
-                           blocks, out_of_time, sleep, preempt,
-                           prev->state, signal_pending(prev), global);
+                TRACE(TS
+                      " blocks:%d out_of_time:%d sleep:%d preempt:%d "
+                      "state:%d sig:%d global:%d\n", TA(prev),
+                      blocks, out_of_time, sleep, preempt,
+                      prev->state, signal_pending(prev), global);
         }
+        raw_spin_unlock(&entry->lock);
+
 
 #ifdef CONFIG_PLUGIN_MC_REDIRECT
         if (smp_processor_id() == interrupt_cpu)
                 fix_global_levels();
 #endif
+
         /* If a task blocks we have no choice but to reschedule */
         if (blocks)
                 remove_from_all(entry->scheduled);
         /* Any task which exhausts its budget or sleeps waiting for its next
          * period completes unless its execution has been forcibly stopped.
          */
-        if ((out_of_time || sleep) && !blocks && !preempt)
+        if ((out_of_time || sleep) && !blocks)/* && !preempt)*/
                 job_completion(entry->scheduled, !sleep);
         /* Global scheduled tasks must wait for a deschedule before they
          * can rejoin the global state. Rejoin them here.
@@ -824,40 +869,12 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
         raw_spin_unlock(&entry->lock);
         local_irq_restore(flags);
         if (next)
-                TRACE_TASK(next, "Scheduled at %llu", litmus_clock());
+                TRACE_MC_TASK(next, "Scheduled at %llu", litmus_clock());
         else if (exists && !next)
-                TRACE("Becomes idle at %llu\n", litmus_clock());
+                TRACE_ENTRY(entry, "Becomes idle at %llu", litmus_clock());
         return next;
 }
 
-static long mc_activate_plugin(void)
-{
-        domain_data_t *dom_data;
-        domain_t *dom;
-        domain_data_t *our_domains[NR_CPUS];
-        int cpu, n = 0;
-        long ret;
-
-#ifdef CONFIG_RELEASE_MASTER
-        interrupt_cpu = atomic_read(&release_master_cpu);
-        if (interrupt_cpu == NO_CPU)
-                interrupt_cpu = 0;
-#endif
-        for_each_online_cpu(cpu) {
-                BUG_ON(NR_CPUS <= n);
-                dom = cpus[cpu]->crit_entries[CRIT_LEVEL_A].domain;
-                dom_data = domain_data(dom);
-                our_domains[cpu] = dom_data;
-                n++;
-        }
-        ret = mc_ce_set_domains(n, our_domains);
-        if (ret)
-                goto out;
-        ret = mc_ce_activate_plugin_common();
-out:
-        return ret;
-}
-
 /*
  * This is the plugin's release at function, called by the release task-set
  * system call. Other places in the file use the generic LITMUS release_at(),
@@ -884,20 +901,57 @@ long mc_deactivate_plugin(void)
 /* Initialize values here so that they are allocated with the module
  * and destroyed when the module is unloaded.
  */
-DEFINE_PER_CPU(cpu_entry_t, _mc_cpus);
+
 /* LVL-A */
-DEFINE_PER_CPU(domain_data_t, _mc_crit_a);
+DEFINE_PER_CPU(struct domain_data, _mc_crit_a);
 DEFINE_PER_CPU(raw_spinlock_t, _mc_crit_a_lock);
 DEFINE_PER_CPU(struct ce_dom_data, _mc_crit_a_ce_data);
 /* LVL-B */
-DEFINE_PER_CPU(domain_data_t, _mc_crit_b);
+DEFINE_PER_CPU(struct domain_data, _mc_crit_b);
 DEFINE_PER_CPU(rt_domain_t, _mc_crit_b_rt);
 /* LVL-C */
-static domain_data_t _mc_crit_c;
+static struct domain_data _mc_crit_c;
 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;
+        struct domain *dom;
+        struct domain_data *our_domains[NR_CPUS];
+        int cpu, n = 0;
+        long ret;
+
+#ifdef CONFIG_RELEASE_MASTER
+        interrupt_cpu = atomic_read(&release_master_cpu);
+        if (interrupt_cpu == NO_CPU)
+                interrupt_cpu = 0;
+#endif
+
+        for_each_online_cpu(cpu) {
+                BUG_ON(NR_CPUS <= n);
+                dom = per_cpu(cpus, cpu).crit_entries[CRIT_LEVEL_A].domain;
+                dom_data = domain_data(dom);
+                our_domains[cpu] = dom_data;
+                n++;
+        }
+        ret = mc_ce_set_domains(n, our_domains);
+        if (ret)
+                goto out;
+        ret = mc_ce_activate_plugin_common();
+out:
+        return ret;
+}
+
 static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
         .plugin_name            = "MC",
         .task_new               = mc_task_new,
@@ -912,8 +966,8 @@ static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
         .deactivate_plugin      = mc_deactivate_plugin,
 };
 
-static void init_crit_entry(crit_entry_t *ce, enum crit_level level,
-                            domain_data_t *dom_data,
+static void init_crit_entry(struct crit_entry *ce, enum crit_level level,
+                            struct domain_data *dom_data,
                             struct bheap_node *node)
 {
         ce->level  = level;
@@ -921,12 +975,17 @@ static void init_crit_entry(crit_entry_t *ce, enum crit_level level,
         ce->node   = node;
         ce->domain = &dom_data->domain;
         ce->usable = 1;
-        atomic_set(&ce->dirty, 1);
+#ifdef CONFIG_MERGE_TIMERS
+        init_event(&ce->event, level, mc_ghost_exhausted,
+                   event_list_alloc(GFP_ATOMIC));
+#else
         hrtimer_init(&ce->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
         ce->timer.function = mc_ghost_exhausted;
+#endif
+
 }
 
-static void init_local_domain(cpu_entry_t *entry, domain_data_t *dom_data,
+static void init_local_domain(struct cpu_entry *entry, struct domain_data *dom_data,
                               enum crit_level level)
 {
         dom_data->heap = NULL;
@@ -934,12 +993,12 @@ static void init_local_domain(cpu_entry_t *entry, domain_data_t *dom_data,
         init_crit_entry(dom_data->crit_entry, level, dom_data, NULL);
 }
 
-static void init_global_domain(domain_data_t *dom_data, enum crit_level level,
+static void init_global_domain(struct domain_data *dom_data, enum crit_level level,
                                struct bheap *heap, struct bheap_node *nodes)
 {
         int cpu;
-        cpu_entry_t *entry;
-        crit_entry_t *ce;
+        struct cpu_entry *entry;
+        struct crit_entry *ce;
         struct bheap_node *node;
 
         dom_data->crit_entry = NULL;
@@ -947,7 +1006,7 @@ static void init_global_domain(domain_data_t *dom_data, enum crit_level level,
         bheap_init(heap);
 
         for_each_online_cpu(cpu) {
-                entry = cpus[cpu];
+                entry = &per_cpu(cpus, cpu);
                 node = &nodes[cpu];
                 ce = &entry->crit_entries[level];
                 init_crit_entry(ce, level, dom_data, node);
@@ -956,37 +1015,59 @@ static void init_global_domain(domain_data_t *dom_data, enum crit_level level,
         }
 }
 
-static inline void init_edf_domain(domain_t *dom, rt_domain_t *rt)
+static inline void init_edf_domain(struct domain *dom, rt_domain_t *rt,
+                                   int timer_cpu, int prio)
 {
         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;
+        rt->prio = prio;
+#else
+        rt->release_master = interrupt_cpu;
+#endif
+#elif CONFIG_MERGE_TIMERS
+        rt->event_group = &_mc_groups[timer_cpu];
+        rt->prio = prio;
+#endif
 }
 
-domain_data_t *ce_domain_for(int);
+struct domain_data *ce_domain_for(int);
 static int __init init_mc(void)
 {
         int cpu;
-        cpu_entry_t *entry;
+        struct cpu_entry *entry;
+        struct domain_data *dom_data;
         rt_domain_t *rt;
-        domain_data_t *dom_data;
-        raw_spinlock_t *a_dom_lock, *b_dom, *c_dom; /* For lock debugger */
+        raw_spinlock_t *a_dom_lock, *b_dom_lock, *c_dom_lock; /* For lock debugger */
         struct ce_dom_data *ce_data;
 
         for_each_online_cpu(cpu) {
-                entry = &per_cpu(_mc_cpus, cpu);
-                cpus[cpu] = entry;
+                entry = &per_cpu(cpus, cpu);
 
                 /* CPU */
                 entry->cpu = cpu;
                 entry->scheduled = NULL;
                 entry->linked = NULL;
                 raw_spin_lock_init(&entry->lock);
+
 #ifdef CONFIG_PLUGIN_MC_REDIRECT
                 raw_spin_lock_init(&entry->redir_lock);
                 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);
@@ -1004,18 +1085,27 @@ 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);
-                b_dom = dom_data->domain.lock;
-                raw_spin_lock_init(b_dom);
+                init_edf_domain(&dom_data->domain, rt, cpu, CRIT_LEVEL_B);
+                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);
-        c_dom = _mc_crit_c.domain.lock;
-        raw_spin_lock_init(c_dom);
+        init_edf_domain(&_mc_crit_c.domain, &_mc_crit_c_rt, 0, CRIT_LEVEL_C);
+        c_dom_lock = _mc_crit_c.domain.lock;
+        raw_spin_lock_init(c_dom_lock);
         _mc_crit_c.domain.name = "LVL-C";
 
         return register_sched_plugin(&mc_plugin);