Split C/D queueswip-mc-jerickso

1 files changed, 65 insertions, 30 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 8e201a48db24..636fa5750bd3 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -127,8 +127,9 @@ DEFINE_PER_CPU(rt_domain_t, crit_a);
 #define remote_a_queue(cpu)     (&per_cpu(crit_a, cpu))
 #define local_a_queue           (&__get_cpu_var(crit_a))
 
-static rt_domain_t crit_c_d;
-#define crit_c_d_lock (crit_c_d.ready_lock)
+static rt_domain_t crit_c;
+static rt_domain_t crit_d;
+#define crit_c_lock (crit_c.ready_lock)
 
 /* BEGIN clone of edf_common.c to allow shared C/D run queue*/
 
@@ -197,10 +198,13 @@ static rt_domain_t *proper_domain(struct task_struct* task)
                 case 1:
                         return remote_b_queue(get_partition(task));
                         break;
+                case 2:
+                        return &crit_c;
+                case 3:
+                        return &crit_d;
                 default:
-                        /*Assume G-EDF*/
-                        return &crit_c_d;
-                        break;
+                        /*Should never get here*/
+                        BUG();
         }
 }
 
@@ -363,18 +367,38 @@ static noinline void requeue(struct task_struct* task)
         }
 }
 
-/* check for any necessary level C and D preemptions */
-static void check_for_gedf_preemptions(void)
+/* check for any necessary level C preemptions */
+static void check_for_c_preemptions(void)
+{
+        struct task_struct *task;
+        cpu_entry_t* last;
+
+        for(last = lowest_prio_cpu();
+            mc_edf_preemption_needed(&crit_c, last->linked);
+            last = lowest_prio_cpu()) {
+                /* preemption necessary */
+                task = __take_ready(&crit_c);
+                TRACE("check_for_c_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);
+        }
+}
+
+/* check for any necessary level D preemptions */
+static void check_for_d_preemptions(void)
 {
         struct task_struct *task;
         cpu_entry_t* last;
 
         for(last = lowest_prio_cpu();
-            mc_edf_preemption_needed(&crit_c_d, last->linked);
+            mc_edf_preemption_needed(&crit_d, last->linked);
             last = lowest_prio_cpu()) {
                 /* preemption necessary */
-                task = __take_ready(&crit_c_d);
-                TRACE("check_for_gedf_preemptions: attempting to link task %d to %d\n",
+                task = __take_ready(&crit_d);
+                TRACE("check_for_d_preemptions: attempting to link task %d to %d\n",
                       task->pid, last->cpu);
                 if (last->linked)
                         requeue(last->linked);
@@ -432,11 +456,16 @@ static noinline void mc_job_arrival(struct task_struct* task)
         if (task->rt_param.task_params.crit == 0){
                 check_for_a_preemption(remote_cpu_entry(get_partition(task)));
         }
-        if (task->rt_param.task_params.crit == 1){
+        else if (task->rt_param.task_params.crit == 1){
                 check_for_pedf_preemption(remote_cpu_entry(
                         get_partition(task)));
         }
-        check_for_gedf_preemptions();
+        else if (task->rt_param.task_params.crit == 2){
+                check_for_c_preemptions();
+        }
+        else if (task->rt_param.task_params.crit == 3){
+                check_for_d_preemptions();
+        }
 }
 
 static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
@@ -444,7 +473,7 @@ static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
         unsigned long flags;
         int i;
 
-        raw_spin_lock_irqsave(&crit_c_d_lock, flags);
+        raw_spin_lock_irqsave(&crit_c_lock, flags);
         TRACE("mc_release_jobs triggered\n");
 
         __merge_ready(rt, tasks);
@@ -457,14 +486,17 @@ static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
                         check_for_a_preemption(remote_cpu_entry(i));
                 }
         }
-        if (rt == &crit_c_d){
-                check_for_gedf_preemptions();
+        if (rt == &crit_c){
+                check_for_c_preemptions();
+        }
+        else if (rt == &crit_d){
+                check_for_d_preemptions();
         }
 
-        raw_spin_unlock_irqrestore(&crit_c_d_lock, flags);
+        raw_spin_unlock_irqrestore(&crit_c_lock, flags);
 }
 
-/* caller holds crit_c_d_lock */
+/* caller holds crit_c_lock */
 static noinline void job_completion(struct task_struct *t, int forced)
 {
         BUG_ON(!t);
@@ -550,7 +582,7 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
                 return NULL;
 #endif
 
-        raw_spin_lock(&crit_c_d_lock);
+        raw_spin_lock(&crit_c_lock);
         clear_will_schedule();
 
         /* sanity checking */
@@ -613,7 +645,9 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
                 if (!ready_task)
                         ready_task = __take_ready(local_b_queue);
                 if (!ready_task)
-                        ready_task = __take_ready(&crit_c_d);
+                        ready_task = __take_ready(&crit_c);
+                if (!ready_task)
+                        ready_task = __take_ready(&crit_d);
                 link_task_to_cpu(ready_task, entry);
                 if (ready_task)
                         TRACE_TASK(ready_task, "Linked task inside scheduler\n");
@@ -642,10 +676,10 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
                         next = prev;
 
         /*TODO: Update name of locking, reflect that we're locking all queues*/
-        raw_spin_unlock(&crit_c_d_lock);
+        raw_spin_unlock(&crit_c_lock);
 
 #ifdef WANT_ALL_SCHED_EVENTS
-        TRACE("crit_c_d_lock released, next=0x%p\n", next);
+        TRACE("crit_c_lock released, next=0x%p\n", next);
 
         if (next)
                 TRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
@@ -680,7 +714,7 @@ static void mc_task_new(struct task_struct * t, int on_rq, int running)
 
         TRACE("mixed crit: task new %d\n", t->pid);
 
-        raw_spin_lock_irqsave(&crit_c_d_lock, flags);
+        raw_spin_lock_irqsave(&crit_c_lock, flags);
 
         /* setup job params */
         release_at(t, litmus_clock());
@@ -707,7 +741,7 @@ static void mc_task_new(struct task_struct * t, int on_rq, int running)
         t->rt_param.linked_on          = NO_CPU;
 
         mc_job_arrival(t);
-        raw_spin_unlock_irqrestore(&crit_c_d_lock, flags);
+        raw_spin_unlock_irqrestore(&crit_c_lock, flags);
 }
 
 static void mc_task_wake_up(struct task_struct *task)
@@ -717,7 +751,7 @@ static void mc_task_wake_up(struct task_struct *task)
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
 
-        raw_spin_lock_irqsave(&crit_c_d_lock, flags);
+        raw_spin_lock_irqsave(&crit_c_lock, flags);
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
          * a semaphore, it should never be treated as a new job release.
@@ -740,7 +774,7 @@ static void mc_task_wake_up(struct task_struct *task)
                 }
         }
         mc_job_arrival(task);
-        raw_spin_unlock_irqrestore(&crit_c_d_lock, flags);
+        raw_spin_unlock_irqrestore(&crit_c_lock, flags);
 }
 
 static void mc_task_block(struct task_struct *t)
@@ -750,9 +784,9 @@ static void mc_task_block(struct task_struct *t)
         TRACE_TASK(t, "block at %llu\n", litmus_clock());
 
         /* unlink if necessary */
-        raw_spin_lock_irqsave(&crit_c_d_lock, flags);
+        raw_spin_lock_irqsave(&crit_c_lock, flags);
         unlink(t);
-        raw_spin_unlock_irqrestore(&crit_c_d_lock, flags);
+        raw_spin_unlock_irqrestore(&crit_c_lock, flags);
 
         BUG_ON(!is_realtime(t));
 }
@@ -763,13 +797,13 @@ static void mc_task_exit(struct task_struct * t)
         unsigned long flags;
 
         /* unlink if necessary */
-        raw_spin_lock_irqsave(&crit_c_d_lock, flags);
+        raw_spin_lock_irqsave(&crit_c_lock, flags);
         unlink(t);
         if (tsk_rt(t)->scheduled_on != NO_CPU) {
                 mc_cpus[tsk_rt(t)->scheduled_on]->scheduled = NULL;
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
-        raw_spin_unlock_irqrestore(&crit_c_d_lock, flags);
+        raw_spin_unlock_irqrestore(&crit_c_lock, flags);
 
         BUG_ON(!is_realtime(t));
         TRACE_TASK(t, "RIP\n");
@@ -842,7 +876,8 @@ static int __init init_mc(void)
                 entry->hn        = &mc_heap_node[cpu];
                 bheap_node_init(&entry->hn, entry);
         }
-        mc_edf_domain_init(&crit_c_d, NULL, mc_release_jobs);
+        mc_edf_domain_init(&crit_c, NULL, mc_release_jobs);
+        mc_edf_domain_init(&crit_d, NULL, mc_release_jobs);
         for (i = 0; i < NR_CPUS; i++){
                 mc_edf_domain_init(remote_b_queue(i), NULL,
                                    mc_release_jobs);