weak level A support

1 files changed, 45 insertions, 7 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index c780ff6bac43..8e201a48db24 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -123,6 +123,10 @@ DEFINE_PER_CPU(rt_domain_t, crit_b);
 #define remote_b_queue(cpu)     (&per_cpu(crit_b, cpu))
 #define local_b_queue           (&__get_cpu_var(crit_b))
 
+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)
 
@@ -188,10 +192,10 @@ static rt_domain_t *proper_domain(struct task_struct* task)
         switch (task->rt_param.task_params.crit)
         {
                 case 0:
-                        /*TODO: implement level A*/
+                        return remote_a_queue(get_partition(task));
+                        break;
                 case 1:
-                        return remote_b_queue(
-                                task->rt_param.task_params.cpu);
+                        return remote_b_queue(get_partition(task));
                         break;
                 default:
                         /*Assume G-EDF*/
@@ -274,7 +278,7 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                          * We can only safely swap if neither task is
                          * partitioned.
                          */
-                        if (0 && entry != sched &&
+                        if (entry != sched &&
                                 linked->rt_param.task_params.crit > 1 &&
                                 (!sched->linked ||
                                 sched->linked->rt_param.task_params.crit > 1)){
@@ -344,9 +348,12 @@ static void preempt(cpu_entry_t *entry)
  */
 static noinline void requeue(struct task_struct* task)
 {
-        BUG_ON(!task);
+        BUG_ON(!task || !is_realtime(task));
         /* sanity check before insertion */
         BUG_ON(is_queued(task));
+        /* Should never call on a level A task.*/
+        /*Allowing this for now*/
+/*      BUG_ON(task->rt_param.task_params.crit == 0);*/
 
         if (is_released(task, litmus_clock()))
                 __add_ready(proper_domain(task), task);
@@ -376,6 +383,24 @@ static void check_for_gedf_preemptions(void)
         }
 }
 
+/* Check for level A preemption*/
+static void check_for_a_preemption(cpu_entry_t* entry)
+{
+        struct task_struct *task;
+        rt_domain_t *queue;
+        queue = remote_a_queue(entry->cpu);
+
+        if (__peek_ready(queue)){
+                task = __take_ready(queue);
+                TRACE("check_for_a_preemption: attempting to link task %d to %d\n",
+                        task->pid, entry->cpu);
+                if (entry->linked)
+                        requeue(entry->linked);
+                link_task_to_cpu(task, entry);
+                preempt(entry);
+        }
+}
+
 /* Check for level B preemption*/
 static void check_for_pedf_preemption(cpu_entry_t* entry)
 {
@@ -399,13 +424,17 @@ static void check_for_pedf_preemption(cpu_entry_t* entry)
 /* mc_job_arrival: task is either resumed or released */
 static noinline void mc_job_arrival(struct task_struct* task)
 {
+        cpu_entry_t *entry;
         BUG_ON(!task);
 
         TRACE("mc_job_arrival triggered\n");
         requeue(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){
                 check_for_pedf_preemption(remote_cpu_entry(
-                                get_partition(task)));
+                        get_partition(task)));
         }
         check_for_gedf_preemptions();
 }
@@ -424,6 +453,9 @@ static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
                 if (rt == remote_b_queue(i)){
                         check_for_pedf_preemption(remote_cpu_entry(i));
                 }
+                else if (rt == remote_a_queue(i)){
+                        check_for_a_preemption(remote_cpu_entry(i));
+                }
         }
         if (rt == &crit_c_d){
                 check_for_gedf_preemptions();
@@ -577,7 +609,9 @@ 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_b_queue);
+                ready_task = __take_ready(local_a_queue);
+                if (!ready_task)
+                        ready_task = __take_ready(local_b_queue);
                 if (!ready_task)
                         ready_task = __take_ready(&crit_c_d);
                 link_task_to_cpu(ready_task, entry);
@@ -813,6 +847,10 @@ static int __init init_mc(void)
                 mc_edf_domain_init(remote_b_queue(i), NULL,
                                    mc_release_jobs);
         }
+        for (i = 0; i < NR_CPUS; i++){
+                mc_edf_domain_init(remote_a_queue(i), NULL,
+                                   mc_release_jobs);
+        }
         return register_sched_plugin(&mc_plugin);
 }