Checkpoint commit for work redistribution

2 files changed, 121 insertions, 25 deletions

diff --git a/litmus/Kconfig b/litmus/Kconfig
index b8f6a9159eb2..d629a2843584 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -23,14 +23,42 @@ config PLUGIN_PFAIR
 
           If unsure, say Yes.
 
+config MERGE_TIMERS
+       bool "Timer-merging Support"
+       depends on HIGH_RES_TIMERS
+       default y
+       help
+         Include support for merging timers.
+
+config MERGE_TIMERS_WINDOW
+       int "Timer-merging Window (in nanoseconds)"
+       depends on MERGE_TIMERS
+       default 1000
+       help
+         Window within which seperate timers may be merged.
+
+config RELEASE_MASTER
+        bool "Release-master Support"
+        depends on ARCH_HAS_SEND_PULL_TIMERS
+        default n
+        help
+          In GSN-EDF, allow one processor to act as a dedicated interrupt
+          processor that services all timer interrupts, but that does not schedule
+          real-time tasks. See RTSS'09 paper for details
+          (http://www.cs.unc.edu/~anderson/papers.html).
+
+menu "Mixed Criticality"
+
 config PLUGIN_MC
        bool "Mixed Criticality Scheduler"
        depends on X86 && SYSFS
        default y
        help
-       Included the mixed criticality scheduler.
+         Include the mixed criticality scheduler. This plugin depends
+         on the global release-master processor for its _REDIRECT and
+         _RELEASE_MASTER options.
 
-       If unsure, say Yes.
+         If unsure, say Yes.
 
 config PLUGIN_MC_LEVEL_A_MAX_TASKS
        int "Maximum level A tasks"
@@ -38,18 +66,24 @@ config PLUGIN_MC_LEVEL_A_MAX_TASKS
        range 1 128
        default 32
        help
-       The maximum number of level A tasks allowed (per-cpu) in level A.
+         The maximum number of level A tasks allowed (per-cpu) in level A.
 
-config RELEASE_MASTER
-        bool "Release-master Support"
-        depends on ARCH_HAS_SEND_PULL_TIMERS
-        default n
-        help
-           Allow one processor to act as a dedicated interrupt processor
-           that services all timer interrupts, but that does not schedule
-           real-time tasks. See RTSS'09 paper for details
-           (http://www.cs.unc.edu/~anderson/papers.html).
-           Currently only supported by GSN-EDF.
+config PLUGIN_MC_RELEASE_MASTER
+       bool "Release-master support for MC"
+       depends on PLUGIN_MC && RELEASE_MASTER
+       default y
+       help
+         Send all timer interrupts to the system-wide release-master CPU.
+
+config PLUGIN_MC_REDIRECT
+       bool "Redirect Work to Release-master"
+       depends on PLUGIN_MC && RELEASE_MASTER
+       default y
+       help
+         Allow processors to send work involving global state to the
+         release-master cpu in order to avoid excess overheads during
+         partitioned decisions.
+endmenu
 
 endmenu
 
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 0ec03b3949d2..fa2cd7ee606b 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -40,6 +40,7 @@ typedef struct {
         int                     usable;
         struct hrtimer          timer;
         struct bheap_node*      node;
+        atomic_t                dirty;
 } crit_entry_t;
 
 /**
@@ -56,6 +57,10 @@ typedef struct {
         struct task_struct*     linked;
         raw_spinlock_t          lock;
         crit_entry_t            crit_entries[NUM_CRIT_LEVELS];
+#ifdef CONFIG_PLUGIN_MC_REDIRECT
+        struct list_head        redir;
+        raw_spinlock_t          redir_lock;
+#endif
 } cpu_entry_t;
 
 /**
@@ -71,6 +76,9 @@ typedef struct {
 } domain_data_t;
 
 static cpu_entry_t* cpus[NR_CPUS];
+#ifdef CONFIG_RELEASE_MASTER
+static int interrupt_cpu;
+#endif
 
 #define domain_data(dom)  (container_of(dom, domain_data_t, domain))
 #define is_global(dom)    (domain_data(dom)->heap)
@@ -279,8 +287,7 @@ static void link_task_to_cpu(cpu_entry_t *entry, struct task_struct *task)
  * @dom Domain from which to draw higher priority task
  * @ce  CPU criticality level to preempt
  *
- * Caller must hold the lock for @dom and @ce's CPU lock. Returns 1 if
- * a physically preemption occurred.
+ * Caller must hold the lock for @dom and @ce's CPU lock.
  */
 static void preempt(domain_t *dom, crit_entry_t *ce)
 {
@@ -302,10 +309,34 @@ static void preempt(domain_t *dom, crit_entry_t *ce)
         }
 }
 
+#ifdef CONFIG_PLUGIN_MC_REDIRECT
+/**
+ * fix_global_levels() - Execute redirected job arrivals on this cpu.
+ */
+static void fix_global_levels(void)
+{
+        int c;
+        cpu_entry_t *e;
+        struct list_head *pos, *safe;
+        struct task_struct *t;
+
+        for_each_online_cpu(c) {
+                e = 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);
+                        list_del(pos);
+                        job_arrival(t);
+                }
+                raw_spin_unlock(&e->redir_lock);
+        }
+}
+#endif
+
 /**
  * update_crit_levels() - Update criticality entries for the new cpu state.
  * This should be called after a new task has been linked to @entry.
- * Assumes the caller holds @entry->lock, but this method will release it.
+ * The caller must hold the @entry->lock, but this method will release it.
  */
 static void update_crit_levels(cpu_entry_t *entry)
 {
@@ -314,24 +345,36 @@ static void update_crit_levels(cpu_entry_t *entry)
         struct task_struct *tasks[NUM_CRIT_LEVELS];
         enum crit_level level = entry_level(entry);
 
-        /* Remove tasks from entries */
+        /* 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;
                 ce->usable = 0;
-                if (ce->linked) {
+                if (ce->linked)
                         link_task_to_crit(ce, NULL);
-                }
         }
-
+        /* Need to unlock so we can access domains */
         raw_spin_unlock(&entry->lock);
 
-        /* Put tasks back into system */
+        /* Re-admit tasks to the system */
         for (i = level + 1; i < NUM_CRIT_LEVELS; i++) {
                 ce = &entry->crit_entries[i];
-                if (tasks[i]) {
+                TRACE("Checking %s\n", ce->domain->name);
+                if (!tasks[i]) continue;
+#ifdef  CONFIG_PLUGIN_MC_REDIRECT
+#ifndef CONFIG_PLUGIN_MC_REDIRECT_ALL
+                if (!is_global_task(tasks[i]))
                         job_arrival(tasks[i]);
+                else
+#endif
+                {
+                        raw_spin_lock(&entry->redir_lock);
+                        list_add(&tsk_rt(tasks[i])->list, &entry->redir);
+                        raw_spin_unlock(&entry->redir_lock);
                 }
+#else
+                job_arrival(tasks[i]);
+#endif
         }
 }
 
@@ -464,8 +507,8 @@ static void job_completion(struct task_struct *task, int forced)
 static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
 {
         unsigned long flags;
-        crit_entry_t *ce = container_of(timer, crit_entry_t, timer);;
         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");
@@ -656,6 +699,10 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
                            prev->state, signal_pending(prev), global);
         }
 
+#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);
@@ -695,13 +742,12 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
                                 raw_spin_unlock(dom->lock);
                                 update_crit_levels(entry);
                                 raw_spin_lock(&entry->lock);
-                                goto picked;
+                                continue;
                         }
                 }
                 raw_spin_unlock(dom->lock);
         }
 
- picked:
         /* Schedule next task */
         next = entry->linked;
         entry->scheduled = next;
@@ -718,6 +764,16 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
         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
  * ************************************************************************** */
@@ -731,6 +787,7 @@ static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
         .task_wake_up           = mc_task_wake_up,
         .task_block             = mc_task_block,
         .admit_task             = mc_admit_task,
+        .activate_plugin        = mc_activate_plugin,
 };
 
 /* Initialize values here so that they are allocated with the module
@@ -758,6 +815,7 @@ 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);
         hrtimer_init(&ce->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
         ce->timer.function = mc_ghost_exhausted;
 }
@@ -816,6 +874,10 @@ static int __init init_mc(void)
                 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
 
                 /* CRIT_LEVEL_A */
                 dom_data = &per_cpu(_mc_crit_a, cpu);