Update CPU queue management functions to account for multiple criticalities

1 files changed, 68 insertions, 12 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 1fad42aaadf2..59d7b6f49ce5 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -94,7 +94,8 @@ typedef struct  {
         struct task_struct*     linked;         /* only RT tasks */
         struct task_struct*     scheduled;      /* only RT tasks */
         atomic_t                will_schedule;  /* prevent unneeded IPIs */
-        struct bheap_node*      hn;
+        struct bheap_node*      hn_c;
+        struct bheap_node*      hn_d;
         struct task_struct*     ghost_tasks[CRIT_LEVEL_D+1];
 } cpu_entry_t;
 
@@ -115,7 +116,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      mc_cpu_heap;
+static struct bheap      mc_cpu_heap_c, mc_cpu_heap_d;
 
 /* Create per-CPU domains for criticality A */
 DEFINE_PER_CPU(rt_domain_t, crit_a);
@@ -155,18 +156,44 @@ static int mc_edf_higher_prio(struct task_struct* first, struct task_struct*
         return edf_higher_prio(first, second);
 }
 
+static int mc_edf_entry_higher_prio(cpu_entry_t* first, cpu_entry_t* second,
+                                        int crit)
+{
+        struct task_struct *first_active, *second_active;
+        first_active = first->linked;
+        second_active = second->linked;
+        if (first->ghost_jobs[crit]){
+                first->active = first->ghost_jobs[crit];
+        }
+        if (second->ghost_jobs[crit]){
+                second->active = second->ghost_jobs[crit];
+        }
+        return mc_edf_higher_prio(first_active, second_active);
+}
+
 /* need_to_preempt - check whether the task t needs to be preempted
  *                   call only with irqs disabled and with  ready_lock acquired
  *                   THIS DOES NOT TAKE NON-PREEMPTIVE SECTIONS INTO ACCOUNT!
  */
-static int mc_edf_preemption_needed(rt_domain_t* rt, struct task_struct *t)
+static int mc_edf_preemption_needed(rt_domain_t* rt, int crit,
+                                        cpu_entry_t* entry)
 {
+        task_struct *active_task;
+
         /* we need the read lock for edf_ready_queue */
         /* no need to preempt if there is nothing pending */
         if (!__jobs_pending(rt))
                 return 0;
+
+        active_task = entry->linked;
+        /* A ghost task can only exist if we haven't scheduled something above
+         * its level
+         */
+        if (entry->ghost_tasks[crit]){
+                active_task = entry->ghost_tasks[crit];
+        }
         /* we need to reschedule if t doesn't exist */
-        if (!t)
+        if (!active_task)
                 return 1;
 
         /* NOTE: We cannot check for non-preemptibility since we
@@ -174,7 +201,8 @@ static int mc_edf_preemption_needed(rt_domain_t* rt, struct task_struct *t)
          */
 
         /* make sure to get non-rt stuff out of the way */
-        return !is_realtime(t) || mc_edf_higher_prio(__next_ready(rt), t);
+        return !is_realtime(active_task) ||
+                mc_edf_higher_prio(__next_ready(rt), active_task);
 }
 
 static int mc_edf_ready_order(struct bheap_node* a, struct bheap_node* b)
@@ -222,7 +250,21 @@ static rt_domain_t* domain_of(struct task_struct* task)
 /* Called by update_cpu_position and lowest_prio_cpu in bheap operations
  *      Callers always have global lock
 */
-static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
+static int cpu_lower_prio_c(struct bheap_node *_a, struct bheap_node *_b)
+{
+        cpu_entry_t *a, *b;
+        a = _a->value;
+        b = _b->value;
+        /* Note that a and b are inverted: we want the lowest-priority CPU at
+         * the top of the heap.
+         */
+        return mc_edf_entry_higher_prio(b, a, CRIT_LEVEL_C);
+}
+
+/* Called by update_cpu_position and lowest_prio_cpu in bheap operations
+ *      Callers always have global lock
+*/
+static int cpu_lower_prio_d(struct bheap_node *_a, struct bheap_node *_b)
 {
         cpu_entry_t *a, *b;
         a = _a->value;
@@ -230,7 +272,7 @@ static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
         /* Note that a and b are inverted: we want the lowest-priority CPU at
          * the top of the heap.
          */
-        return mc_edf_higher_prio(b->linked, a->linked);
+        return mc_edf_entry_higher_prio(b, a, CRIT_LEVEL_D);
 }
 
 /* update_cpu_position - Move the cpu entry to the correct place to maintain
@@ -241,19 +283,33 @@ static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
  */
 static void update_cpu_position(cpu_entry_t *entry)
 {
-        if (likely(bheap_node_in_heap(entry->hn)))
-                bheap_delete(cpu_lower_prio, &mc_cpu_heap, entry->hn);
-        bheap_insert(cpu_lower_prio, &mc_cpu_heap, entry->hn);
+        if (likely(bheap_node_in_heap(entry->hn_c)))
+                bheap_delete(cpu_lower_prio_c, &mc_cpu_heap_c, entry->hn_c);
+        if (likely(bheap_node_in_heap(entry->hn_d)))
+                bheap_delete(cpu_lower_prio_d, &mc_dpu_heap_d, entry->hn_d);
+        bheap_insert(cpu_lower_prio, &mc_cpu_heap_c, entry->hn_c);
+        bheap_insert(cpu_lower_prio, &mc_cpu_heap_d, entry->hn_d);
+}
+
+/* caller must hold global lock
+ * Only called when checking for gedf preemptions by check_for_gedf_preemptions,
+ *      which always has global lock
+ */
+static cpu_entry_t* lowest_prio_cpu_c(void)
+{
+        struct bheap_node* hn;
+        hn = bheap_peek(cpu_lower_prio_c, &mc_cpu_heap_c);
+        return hn->value;
 }
 
 /* caller must hold global lock
  * Only called when checking for gedf preemptions by check_for_gedf_preemptions,
  *      which always has global lock
  */
-static cpu_entry_t* lowest_prio_cpu(void)
+static cpu_entry_t* lowest_prio_cpu_d(void)
 {
         struct bheap_node* hn;
-        hn = bheap_peek(cpu_lower_prio, &mc_cpu_heap);
+        hn = bheap_peek(cpu_lower_prio_d, &mc_cpu_heap_d);
         return hn->value;
 }