Update for per-cpu domains

1 files changed, 63 insertions, 20 deletions

diff --git a/litmus/sched_mcrit.c b/litmus/sched_mcrit.c
index 0d26b3b158da..5d57a0e43412 100644
--- a/litmus/sched_mcrit.c
+++ b/litmus/sched_mcrit.c
@@ -99,6 +99,7 @@ typedef struct  {
         struct task_struct*     scheduled;      /* only RT tasks */
         atomic_t                will_schedule;  /* prevent unneeded IPIs */
         struct bheap_node*      hn;
+    rt_domain_t rt_domain;          /* rt domain for tasks assigned to this CPU */
 } cpu_entry_t;
 DEFINE_PER_CPU(cpu_entry_t, mcrit_cpu_entries);
 
@@ -291,36 +292,63 @@ static void preempt(cpu_entry_t *entry)
  */
 static noinline void requeue(struct task_struct* task)
 {
+    rt_domain_t* domain; /* either a per-CPU domain or the mcrit global domain */
+    cpu_entry_t* entry; /* if task is partitioned, the cpu_entry for its CPU */
+
         BUG_ON(!task);
         /* sanity check before insertion */
         BUG_ON(is_queued(task));
 
+    if (task->rt_param.task_params.crit > CRIT_LEVEL_C) {
+        entry = mcrit_cpus[task->rt_param.task_params.cpu]
+        domain = entry->rt_domain;
+    }
+    else {
+        domain = &mcrit;
+    }
+
         if (is_released(task, litmus_clock()))
-                __add_ready(&mcrit, task);
+                __add_ready(domain, task);
         else {
                 /* it has got to wait */
-                add_release(&mcrit, task);
+                add_release(domain, task);
         }
 }
 
 /* check for any necessary preemptions */
 static void check_for_preemptions(void)
 {
+    int cpu;
         struct task_struct *task;
         cpu_entry_t* last;
+    rt_domain_t* domain;
+
+    for (cpu = 0; cpu < NR_CPUS; cpu++)  {
+        last = mcrit_cpus[cpu];
+        domain = &(last->rt_domain);
+        if (mcrit_edf_preemption_needed(domain, last->linked)) {
+            task = __take_ready(domain);
+            TRACE("check_for_preemptions: attempting to link task %d to %d\n",
+                  task->pid, last->cpu);
+            if (last->linked)
+                requeue(last->linked);
+            link_task_to_cpu(task, last);
+            preempt(last);
+        }
+    }
 
-        for(last = lowest_prio_cpu();
-            mcrit_edf_preemption_needed(&mcrit, last->linked);
-            last = lowest_prio_cpu()) {
-                /* preemption necessary */
-                task = __take_ready(&mcrit);
-                TRACE("check_for_preemptions: attempting to link task %d to %d\n",
-                      task->pid, last->cpu);
-                if (last->linked)
-                        requeue(last->linked);
-                link_task_to_cpu(task, last);
-                preempt(last);
-        }
+    for(last = lowest_prio_cpu();
+        mcrit_edf_preemption_needed(&mcrit, last->linked);
+        last = lowest_prio_cpu()) {
+        /* preemption necessary */
+        task = __take_ready(&mcrit);
+        TRACE("check_for_preemptions: attempting to link task %d to %d\n",
+              task->pid, last->cpu);
+        if (last->linked)
+            requeue(last->linked);
+        link_task_to_cpu(task, last);
+        preempt(last);
+    }
 }
 
 /* mcrit_job_arrival: task is either resumed or released */
@@ -336,15 +364,15 @@ static void mcrit_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 {
         unsigned long flags;
 
-        raw_spin_lock_irqsave(&mcrit_lock, flags);
+        raw_spin_lock_irqsave(&(rt->ready_lock), flags);
 
         __merge_ready(rt, tasks);
         check_for_preemptions();
 
-        raw_spin_unlock_irqrestore(&mcrit_lock, flags);
+        raw_spin_unlock_irqrestore(&(rt->ready_lock), flags);
 }
 
-/* caller holds mcrit_lock */
+/* caller holds mcrit_lock and/or cpu domain lock */
 static noinline void job_completion(struct task_struct *t, int forced)
 {
         BUG_ON(!t);
@@ -418,6 +446,7 @@ static void mcrit_tick(struct task_struct* t)
 static struct task_struct* mcrit_schedule(struct task_struct * prev)
 {
         cpu_entry_t* entry = &__get_cpu_var(mcrit_cpu_entries);
+    rt_domain_t* cpu_domain = &(cpu_entry_t->rt_domain);
         int out_of_time, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
 
@@ -430,6 +459,7 @@ static struct task_struct* mcrit_schedule(struct task_struct * prev)
 #endif
 
         raw_spin_lock(&mcrit_lock);
+    raw_spin_lock(&(cpu_domain->ready_lock)); /* not sure if this is needed? */
         clear_will_schedule();
 
         /* sanity checking */
@@ -487,7 +517,9 @@ static struct task_struct* mcrit_schedule(struct task_struct * prev)
 
         /* Link pending task if we became unlinked.
          */
-        if (!entry->linked)
+        if (!entry->linked) /*first, try from this cpu's tasks */
+                link_task_to_cpu(__take_ready(cpu_domain), entry);
+        if (!entry->linked) /* still nothing? get a global task */
                 link_task_to_cpu(__take_ready(&mcrit), entry);
 
         /* The final scheduling decision. Do we need to switch for some reason?
@@ -512,6 +544,7 @@ static struct task_struct* mcrit_schedule(struct task_struct * prev)
                 if (exists)
                         next = prev;
 
+    raw_spin_unlock(&(cpu_domain->ready_lock)); /* not sure if this is needed? */
         raw_spin_unlock(&mcrit_lock);
 
 #ifdef WANT_ALL_SCHED_EVENTS
@@ -547,11 +580,20 @@ static void mcrit_task_new(struct task_struct * t, int on_rq, int running)
 {
         unsigned long           flags;
         cpu_entry_t*            entry;
+    raw_spinlock_t*     lock; /* lock depends on rt domain */
 
         TRACE("mcrit: task new %d\n", t->pid);
     TRACE("mcrit: task criticality %d\n", t->rt_param.task_params.crit);
 
-        raw_spin_lock_irqsave(&mcrit_lock, flags);
+    if (t->rt_param.task_params.crit > CRIT_LEVEL_C) {
+        entry = mcrit_cpus[t->rt_param.task_params.cpu];
+        lock = &(entry->rt_domain.ready_lock);
+    }
+    else {
+        lock = &mcrit_lock;
+    }
+
+        raw_spin_lock_irqsave(lock, flags);
 
         /* setup job params */
         release_at(t, litmus_clock());
@@ -578,7 +620,7 @@ static void mcrit_task_new(struct task_struct * t, int on_rq, int running)
         t->rt_param.linked_on          = NO_CPU;
 
         mcrit_job_arrival(t);
-        raw_spin_unlock_irqrestore(&mcrit_lock, flags);
+        raw_spin_unlock_irqrestore(lock, flags);
 }
 
 static void mcrit_task_wake_up(struct task_struct *task)
@@ -711,6 +753,7 @@ static int __init init_m_crit(void)
                 entry->cpu       = cpu;
                 entry->hn        = &mcrit_heap_node[cpu];
                 bheap_node_init(&entry->hn, entry);
+        edf_domain_init(&entry->rt_domain, NULL, mcrit_release_jobs);
         }
         mcrit_edf_domain_init(&mcrit, NULL, mcrit_release_jobs);
         return register_sched_plugin(&m_crit_plugin);