1 files changed, 109 insertions, 32 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index f4b2a46fd077..92b847495673 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -115,7 +115,7 @@ cpu_entry_t* mc_cpus[NR_CPUS];
 
 
 /* the cpus queue themselves according to priority in here */
-static struct bheap_node mc_heap_node[NR_CPUS];
+static struct bheap_node mc_heap_node_c[NR_CPUS], mc_heap_node_d[NR_CPUS];
 static struct bheap      mc_cpu_heap_c, mc_cpu_heap_d;
 
 /* Create per-CPU domains for criticality A */
@@ -437,8 +437,8 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                                         i < CRIT_LEVEL_D + 1; i++){
                                         if (entry->ghost_tasks[i]){
                                                 unlink(entry->ghost_tasks[i]);
-                                                /*TODO: make sure booted tasks
-                                                 * get rescheduled if needed
+                                                /* WARNING: it is up to the
+                                                 * caller to requeue ghost jobs
                                                  */
                                         }
                                 }
@@ -546,30 +546,65 @@ static noinline void requeue(struct task_struct* task)
         }
 }
 
-static void prepare_preemption(rt_domain_t *dom, cpu_entry_t *cpu) {
+static void prepare_preemption(rt_domain_t *dom, cpu_entry_t *cpu, int crit) {
         struct task_struct* task;
+        int i;
         task = __take_ready(dom);
         TRACE("prepare_preemption: attempting to link task %d to %d\n",
                 task->pid, cpu->cpu);
-        if (cpu->linked)
-                requeue(cpu->linked);
+        if (is_ghost(task)){
+                /* Changing ghost task only affects linked task at our level */
+                if (cpu->linked && cpu->linked->rt_param.task_params.crit ==
+                                crit)
+                        requeue(cpu->linked);
+                /* Can change ghost task at our level as well. */
+                if (cpu->ghost_jobs[crit])
+                        requeue(cpu->ghost_jobs[crit]);
+        }
+        else{
+                /* Changing linked tasks could affect both real and ghost                        * tasks at multiple levels
+                 */
+                if (cpu->linked)
+                        requeue(cpu->linked);
+                for (i = crit; i <= CRIT_LEVEL_D; i++) {
+                        if (cpu->ghost_jobs[i])
+                                requeue(cpu->ghost_jobs[i]);
+                }
+        }
         link_task_to_cpu(task, cpu);
         preempt(cpu);
 }
 
-/* Callers always have global lock */
-static void check_for_gedf_preemptions(rt_domain_t *dom){
+/* Callers always have global lock for functions in this section*/
+static void check_for_c_preemptions(rt_domain_t *dom){
+        cpu_entry_t* last;
+        for (last = lowest_prio_cpu_c();
+                        mc_edf_preemption_needed(dom, CRIT_LEVEL_C, 
+                                        last->linked);
+                        last = lowest_prio_cpu_c()) {
+                prepare_preemption(dom, last, CRIT_LEVEL_C);
+        }
+}
+
+static void check_for_d_preemptions(rt_domain_t *dom){
         cpu_entry_t* last;
-        for (last = lowest_prio_cpu();
-                        mc_edf_preemption_needed(dom, last->linked);
-                        last = lowest_prio_cpu()) {
-                prepare_preemption(dom, last);
+        for (last = lowest_prio_cpu_d();
+                        mc_edf_preemption_needed(dom, CRIT_LEVEL_D, 
+                                        last->linked);
+                        last = lowest_prio_cpu_d()) {
+                prepare_preemption(dom, last, CRIT_LEVEL_D);
         }
 }
 
-static void check_for_pedf_preemption(rt_domain_t *dom, cpu_entry_t *cpu) {
-        if (mc_edf_preemption_needed(dom, cpu->linked)) {
-                prepare_preemption(dom, cpu);
+static void check_for_a_preemption(rt_domain_t *dom, cpu_entry_t *cpu) {
+        if (mc_edf_preemption_needed(dom, CRIT_LEVEL_A, cpu->linked)) {
+                prepare_preemption(dom, cpu, CRIT_LEVEL_A);
+        }
+}
+
+static void check_for_b_preemption(rt_domain_t *dom, cpu_entry_t *cpu) {
+        if (mc_edf_preemption_needed(dom, CRIT_LEVEL_B, cpu->linked)) {
+                prepare_preemption(dom, cpu, CRIT_LEVEL_B);
         }
 }
 
@@ -585,18 +620,18 @@ static noinline void mc_job_arrival(struct task_struct* task)
         TRACE("mc_job_arrival triggered\n");
         requeue(task);
         if (task->rt_param.task_params.crit == CRIT_LEVEL_A){
-                check_for_pedf_preemption(remote_a_queue(get_partition(task)),
+                check_for_a_preemption(remote_a_queue(get_partition(task)),
                         remote_cpu_entry(get_partition(task)));
         }
         else if (task->rt_param.task_params.crit == CRIT_LEVEL_B){
-                check_for_pedf_preemption(remote_b_queue(get_partition(task)),
+                check_for_a_preemption(remote_b_queue(get_partition(task)),
                         remote_cpu_entry(get_partition(task)));
         }
         else if (task->rt_param.task_params.crit == CRIT_LEVEL_C){
-                check_for_gedf_preemptions(&crit_c);
+                check_for_c_preemptions(&crit_c);
         }
         else if (task->rt_param.task_params.crit == CRIT_LEVEL_D){
-                check_for_gedf_preemptions(&crit_d);
+                check_for_d_preemptions(&crit_d);
         }
 }
 
@@ -616,14 +651,17 @@ static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 
         for (i = 0; i < NR_CPUS; i++){
                 if (rt == remote_b_queue(i)){
-                        check_for_pedf_preemption(rt, remote_cpu_entry(i));
+                        check_for_b_preemption(rt, remote_cpu_entry(i));
                 }
                 else if (rt == remote_a_queue(i)){
-                        check_for_pedf_preemption(rt, remote_cpu_entry(i));
+                        check_for_a_preemption(rt, remote_cpu_entry(i));
                 }
         }
-        if (rt == &crit_c || rt == &crit_d){
-                check_for_gedf_preemptions(rt);
+        if (rt == &crit_c){
+                check_for_c_preemptions(rt);
+        }
+        if (rt == &crit_d){
+                check_for_d_preemptions(rt);
         }
 
         raw_spin_unlock_irqrestore(&global_lock, flags);
@@ -665,6 +703,9 @@ static noinline void job_completion(struct task_struct *t, int forced)
                 }
         }
         /* prepare for next period */
+        /* TODO: check what happens if we actually finish with exactly our
+         * budget and never convert to ghost
+         */
         if (is_ghost(t)) {
                 t->rt_param.job_params.ghost_budget = 0;
                 prepare_for_next_period(t);
@@ -751,6 +792,7 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
         int out_of_time, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
         struct task_struct* ready_task = NULL;
+        int ready_crit, i;
 
 #ifdef CONFIG_RELEASE_MASTER
         /* Bail out early if we are the release master.
@@ -819,16 +861,48 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
         /* Link pending task if we became unlinked.
          */
         if (!entry->linked){
-                ready_task = __take_ready(local_a_queue);
-                if (!ready_task)
+                if (!entry->ghost_tasks[CRIT_LEVEL_A]) {
+                        ready_task = __take_ready(local_a_queue);
+                        ready_crit = CRIT_LEVEL_A;
+                        if (ready_task && is_ghost(ready_task)) {
+                                link_task_to_cpu(ready_task, entry);
+                                ready_task = NULL;
+                        }
+                }
+                if (!ready_task && !entry->ghost_tasks[CRIT_LEVEL_B]) {
                         ready_task = __take_ready(local_b_queue);
-                if (!ready_task)
+                        ready_crit = CRIT_LEVEL_C;
+                        if (ready_task && is_ghost(ready_task)) {
+                                link_task_to_cpu(ready_task, entry);
+                                ready_task = NULL;
+                        }
+                }
+                if (!ready_task && !entry->ghost_tasks[CRIT_LEVEL_C]) {
                         ready_task = __take_ready(&crit_c);
-                if (!ready_task)
+                        ready_crit = CRIT_LEVEL_C;
+                        if (ready_task && is_ghost(ready_task)) {
+                                link_task_to_cpu(ready_task, entry);
+                                ready_task = NULL;
+                        }
+                }
+                if (!ready_task && !entry->ghost_tasks[CRIT_LEVEL_D]) {
                         ready_task = __take_ready(&crit_d);
+                        ready_crit = CRIT_LEVEL_D;
+                        if (ready_task && is_ghost(ready_task)) {
+                                link_task_to_cpu(ready_task, entry);
+                                ready_task = NULL;
+                        }
+                }
+                if (!ready_task) {
+                        ready_crit = CRIT_LEVEL_D + 1;
+                }
+                for (i = ready_crit; i <= CRIT_LEVEL_D; i++) {
+                        requeue(entry->ghost_tasks[i]);
+                }
                 link_task_to_cpu(ready_task, entry);
                 if (ready_task)
-                        TRACE_TASK(ready_task, "Linked task inside scheduler\n");
+                        TRACE_TASK(ready_task,
+                                        "Linked task inside scheduler\n");
         }
 
         /* The final scheduling decision. Do we need to switch for some reason?
@@ -1061,17 +1135,20 @@ static int __init init_mc(void)
 {
         int cpu;
         int i;
-        cpu_entry_t *entry;
+        cpu_entry_t *entry_c, *entry_d;
 
-        bheap_init(&mc_cpu_heap);
+        bheap_init(&mc_cpu_heap_c);
+        bheap_init(&mc_cpu_heap_d);
         /* initialize CPU state */
         for (cpu = 0; cpu < NR_CPUS; cpu++)  {
                 entry = &per_cpu(mc_cpu_entries, cpu);
                 mc_cpus[cpu] = entry;
                 atomic_set(&entry->will_schedule, 0);
                 entry->cpu       = cpu;
-                entry->hn        = &mc_heap_node[cpu];
-                bheap_node_init(&entry->hn, entry);
+                entry->hn_c      = &mc_heap_node_c[cpu];
+                entry->hn_d      = &mc_heap_node_d[cpu];
+                bheap_node_init(&entry->hn_c, entry);
+                bheap_node_init(&entry->hn_d, entry);
         }
         mc_edf_domain_init(&crit_c, NULL, mc_release_jobs);
         mc_edf_domain_init(&crit_d, NULL, mc_release_jobs);