Timer merging

1 files changed, 214 insertions, 125 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 577e7d36faf5..30898246ea38 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -22,6 +22,7 @@
 #include <litmus/sched_trace.h>
 #include <litmus/domain.h>
 #include <litmus/bheap.h>
+#include <litmus/event_group.h>
 
 #include <litmus/sched_mc.h>
 
@@ -34,85 +35,84 @@
  * @timer       For ghost task budget enforcement
  * @node        Used to sort crit_entries by preemptability in global domains
  */
-typedef struct {
+struct crit_entry {
         enum crit_level         level;
         struct task_struct*     linked;
-        domain_t*               domain;
+        struct domain*          domain;
         int                     usable;
+#ifdef CONFIG_MERGE_TIMERS
+        struct rt_event         event;
+#else
         struct hrtimer          timer;
+#endif
         struct bheap_node*      node;
-        atomic_t                dirty;
-} crit_entry_t;
+};
 
 /**
- * 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
+};
 
 /**
- * domain_data_t - Wrap domains with related CPU state
+ * struct domain_data - Wrap domains with related CPU state
  * @domain      A domain for a criticality level
  * @heap        The preemptable heap of crit entries (for global domains)
  * @crit_entry  The crit entry for this domain (for partitioned domains)
  */
-typedef struct {
-        domain_t        domain;
-        struct bheap*   heap;
-        crit_entry_t*   crit_entry;
-} domain_data_t;
+struct domain_data {
+        struct domain           domain;
+        struct bheap*           heap;
+        struct crit_entry*      crit_entry;
+};
 
-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)
+        TRACE("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",                \
               (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;
@@ -134,7 +134,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.
  */
-static 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) {
@@ -149,15 +149,45 @@ static 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(&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
+        struct event_group* group = (is_global(ce->domain)) ?
+                global_group : crit_cpu(ce)->event_group;
+        add_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)
@@ -167,14 +197,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;
         }
@@ -184,7 +214,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;
@@ -198,10 +228,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);
@@ -218,11 +248,7 @@ static void link_task_to_crit(crit_entry_t *ce,
                         task->se.exec_start = litmus_clock();
                         when_to_fire = litmus_clock() +
                                 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);
                 }
         }
 
@@ -234,17 +260,18 @@ static void link_task_to_crit(crit_entry_t *ce,
         }
 }
 
-static void 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);
@@ -257,7 +284,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");
         }
 }
 
@@ -267,7 +294,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;
@@ -278,9 +305,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);
@@ -299,18 +326,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");
         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);
                 }
@@ -324,10 +351,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));
 
@@ -348,10 +375,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));
@@ -373,17 +400,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);
@@ -394,8 +429,8 @@ 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]);
         }
 }
 
@@ -405,11 +440,11 @@ static void update_crit_levels(cpu_entry_t *entry)
  * 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..
  */
-static void 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)) {
                 /* Loop until we find a non-preemptable CPU */
@@ -443,17 +478,17 @@ static void 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 */
@@ -492,7 +527,7 @@ static void remove_from_all(struct task_struct* task)
  */
 static void job_completion(struct task_struct *task, int forced)
 {
-        TRACE_TASK(task, "Completed");
+        TRACE_MC_TASK(task, "Completed");
         sched_trace_task_completion(task, forced);
         BUG_ON(!task);
 
@@ -525,11 +560,19 @@ 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");
@@ -553,7 +596,9 @@ 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
 }
 
 /**
@@ -563,10 +608,10 @@ 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_MC_TASK(first, "Jobs released");
         __merge_ready(rt, tasks);
         check_for_preempt(dom);
         raw_spin_unlock_irqrestore(dom->lock, flags);
@@ -579,7 +624,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);
@@ -587,9 +632,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 */
@@ -619,7 +664,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_MC_TASK(task, "Wakes up");
         if (is_tardy(task, now)) {
                 /* Task missed its last release */
                 release_at(task, now);
@@ -638,7 +683,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_MC_TASK(task, "Block at %llu", litmus_clock());
         remove_from_all(task);
         local_irq_restore(flags);
 }
@@ -651,11 +696,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_MC_TASK(task, "RIP");
 
         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;
         }
 
@@ -689,9 +734,9 @@ static long mc_admit_task(struct task_struct* task)
 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;
 
@@ -703,6 +748,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) &&
@@ -715,17 +761,20 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
 
         if (exists) {
                 entry->scheduled->rt_param.scheduled_on = NO_CPU;
-                TRACE_TASK(prev,
+                TRACE_MC_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);
         }
+        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);
@@ -769,6 +818,7 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
                                 raw_spin_unlock(dom->lock);
                                 update_crit_levels(entry);
                                 raw_spin_lock(&entry->lock);
+                                continue;
                         }
                 }
                 raw_spin_unlock(dom->lock);
@@ -784,22 +834,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());
         return next;
 }
 
-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;
-#endif
-        return 0;
-}
-
 /* **************************************************************************
  * Initialization
  * ************************************************************************** */
@@ -807,23 +847,36 @@ static long mc_activate_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(rt_domain_t, _mc_crit_a_rt);
 /* 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];
 
-/*
- * XXX commented out because I think this was an obvious typo
- */
-/* release_at)_ */
+#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)
+{
+#ifdef CONFIG_RELEASE_MASTER
+        interrupt_cpu = atomic_read(&release_master_cpu);
+        if (interrupt_cpu == NO_CPU)
+                interrupt_cpu = 0;
+#endif
+        return 0;
+}
 
 static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
         .plugin_name            = "MC",
@@ -837,8 +890,8 @@ static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
         .activate_plugin        = mc_activate_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;
@@ -846,12 +899,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;
@@ -859,12 +917,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;
@@ -872,7 +930,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);
@@ -881,40 +939,62 @@ 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
 }
 
 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, *b_dom, *c_dom; /* For lock debugger */
 
         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);
                 rt = &per_cpu(_mc_crit_a_rt, cpu);
                 init_local_domain(entry, dom_data, CRIT_LEVEL_A);
-                init_edf_domain(&dom_data->domain, rt);
+                init_edf_domain(&dom_data->domain, rt, cpu, CRIT_LEVEL_A);
                 a_dom = dom_data->domain.lock;
                 raw_spin_lock_init(a_dom);
                 dom_data->domain.name = "LVL-A";
@@ -923,16 +1003,25 @@ 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);
+                init_edf_domain(&dom_data->domain, rt, cpu, CRIT_LEVEL_B);
                 b_dom = dom_data->domain.lock;
                 raw_spin_lock_init(b_dom);
                 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);
+        init_edf_domain(&_mc_crit_c.domain, &_mc_crit_c_rt, 0, CRIT_LEVEL_C);
         c_dom = _mc_crit_c.domain.lock;
         raw_spin_lock_init(c_dom);
         _mc_crit_c.domain.name = "LVL-C";