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);