Formatting

1 files changed, 35 insertions, 65 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 1f2b13c6a219..0ec03b3949d2 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -4,10 +4,6 @@
  * Implementation of the Mixed Criticality scheduling algorithm.
  *
  * (Per Mollison, Erickson, Anderson, Baruah, Scoredos 2010)
- *
- * This version uses the simple approach and serializes all scheduling
- * decisions by the use of a queue lock. This is probably not the
- * best way to do it, but it should suffice for now.
  */
 
 #include <linux/spinlock.h>
@@ -75,7 +71,6 @@ typedef struct {
 } domain_data_t;
 
 static cpu_entry_t* cpus[NR_CPUS];
-static raw_spinlock_t global_lock;
 
 #define domain_data(dom)  (container_of(dom, domain_data_t, domain))
 #define is_global(dom)    (domain_data(dom)->heap)
@@ -86,8 +81,7 @@ static raw_spinlock_t global_lock;
         (((e)->linked) ? tsk_mc_crit((e)->linked) : NUM_CRIT_LEVELS - 1)
 #define crit_cpu(ce) \
         (container_of((void*)((ce) - (ce)->level), cpu_entry_t, crit_entries))
-
-/* useful debug macros */
+/* Useful debug macros */
 #define TS "(%s/%d:%d:%s)"
 #define TA(t) (t) ? (is_ghost(t)) ? "ghost" : t->comm : "NULL", (t) ? t->pid : 1, \
               (t) ? t->rt_param.job_params.job_no : 1,                  \
@@ -115,7 +109,6 @@ static int cpu_lower_prio(struct bheap_node *a, struct bheap_node *b)
         second = b->value;
         first_link  = first->linked;
         second_link = second->linked;
-
         if (!first->usable || !second->usable) {
                 return second->usable && first->usable;
         } else if (!first_link || !second_link) {
@@ -134,7 +127,6 @@ static int cpu_lower_prio(struct bheap_node *a, struct bheap_node *b)
 static noinline int mc_preempt_needed(domain_t *dom, struct task_struct* curr)
 {
         struct task_struct *next = dom->peek_ready(dom);
-
         if (!next || !curr) {
                 return next && !curr;
         } else {
@@ -150,8 +142,7 @@ static noinline int mc_preempt_needed(domain_t *dom, struct task_struct* curr)
 static inline crit_entry_t* lowest_prio_cpu(domain_t *dom)
 {
         struct bheap *heap = domain_data(dom)->heap;
-        struct bheap_node* hn;
-        hn = bheap_peek(cpu_lower_prio, heap);
+        struct bheap_node* hn = bheap_peek(cpu_lower_prio, heap);
         return (hn) ? hn->value : NULL;
 }
 
@@ -161,11 +152,9 @@ static inline crit_entry_t* lowest_prio_cpu(domain_t *dom)
  */
 static void update_ghost_time(struct task_struct *p)
 {
-        u64 delta, clock;
-
+        u64 clock = litmus_clock();
+        u64 delta = clock - p->se.exec_start;
         BUG_ON(!is_ghost(p));
-        clock = litmus_clock();
-        delta = clock - p->se.exec_start;
         if (unlikely ((s64)delta < 0)) {
                 delta = 0;
                 TRACE_TASK(p, "WARNING: negative time delta");
@@ -236,7 +225,6 @@ static void link_task_to_crit(crit_entry_t *ce,
 }
 
 static void check_for_preempt(domain_t*);
-
 /**
  * job_arrival() - Called when a task re-enters the system.
  * Caller must hold no locks.
@@ -247,7 +235,6 @@ static void job_arrival(struct task_struct *task)
 
         TRACE_TASK(task, "Job arriving");
         BUG_ON(!task);
-
         raw_spin_lock(dom->lock);
         if (can_requeue(task)) {
                 dom->requeue(dom, task);
@@ -271,16 +258,16 @@ static void job_arrival(struct task_struct *task)
  */
 static void link_task_to_cpu(cpu_entry_t *entry, struct task_struct *task)
 {
-        int i;
+        int i = entry_level(entry);
         TRACE_TASK(task, "Linking to P%d", entry->cpu);
         BUG_ON(task && tsk_rt(task)->linked_on != entry->cpu);
         BUG_ON(task && is_ghost(task));
 
-        i = entry_level(entry);
         if (task){
                 set_rt_flags(task, RT_F_RUNNING);
         }
         entry->linked = task;
+        /* Higher criticality crit entries are now usable */
         for (; i < entry_level(entry) + 1; i++) {
                 TRACE_CRIT_ENTRY(&entry->crit_entries[i], "now usable");
                 entry->crit_entries[i].usable = 1;
@@ -295,9 +282,8 @@ static void link_task_to_cpu(cpu_entry_t *entry, struct task_struct *task)
  * Caller must hold the lock for @dom and @ce's CPU lock. Returns 1 if
  * a physically preemption occurred.
  */
-static int preempt(domain_t *dom, crit_entry_t *ce)
+static void preempt(domain_t *dom, crit_entry_t *ce)
 {
-        int rv = 0;
         struct task_struct *task = dom->take_ready(dom);
         cpu_entry_t *entry = crit_cpu(ce);
 
@@ -309,14 +295,11 @@ static int preempt(domain_t *dom, crit_entry_t *ce)
                 dom->requeue(dom, ce->linked);
         }
         link_task_to_crit(ce, task);
-
         /* Preempt actual execution if this is a running task */
         if (!is_ghost(task)) {
                 link_task_to_cpu(entry, task);
                 preempt_if_preemptable(entry->scheduled, entry->cpu);
-                rv = 1;
         }
-        return rv;
 }
 
 /**
@@ -335,7 +318,6 @@ static void update_crit_levels(cpu_entry_t *entry)
         for (i = level + 1; i < NUM_CRIT_LEVELS; i++) {
                 ce = &entry->crit_entries[i];
                 tasks[i] = ce->linked;
-                TRACE_CRIT_ENTRY(ce, "not usable");
                 ce->usable = 0;
                 if (ce->linked) {
                         link_task_to_crit(ce, NULL);
@@ -380,7 +362,6 @@ static void check_for_preempt(domain_t *dom)
         } else /* Partitioned */ {
                 ce = domain_data(dom)->crit_entry;
                 entry = crit_cpu(ce);
-
                 raw_spin_lock(&entry->lock);
                 if (ce->usable && dom->preempt_needed(dom, ce->linked)) {
                         preempt(dom, ce);
@@ -406,11 +387,12 @@ static void remove_from_all(struct task_struct* task)
         BUG_ON(!task);
 
         raw_spin_lock(dom->lock);
+
         if (task->rt_param.linked_on != NO_CPU) {
                 entry = cpus[task->rt_param.linked_on];
-