Cleanup. Not tested

1 files changed, 27 insertions, 65 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 84fdc304b434..f3ace9fe560a 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -61,8 +61,6 @@ DEFINE_PER_CPU(struct cpu_entry, cpus);
 static int interrupt_cpu;
 #endif
 
-#define FTRACE_CPU 6
-
 #define domain_data(dom)  (container_of(dom, struct domain_data, domain))
 #define is_global(dom)    (domain_data(dom)->heap)
 #define is_global_task(t) (is_global(get_task_domain(t)))
@@ -151,11 +149,9 @@ static void fix_crit_position(struct crit_entry *ce)
         if (is_global(ce->domain)) {
                 if (CS_ACTIVATE == ce->state) {
                         ce->state = CS_ACTIVE;
-                        TRACE_CRIT_ENTRY(ce, "CS_ACTIVE\n");
                         update_crit_position(ce);
                 } else if (CS_REMOVE == ce->state) {
                         ce->state = CS_REMOVED;
-                        TRACE_CRIT_ENTRY(ce, "CS_REMOVED\n");
                         update_crit_position(ce);
                 }
         }
@@ -389,7 +385,6 @@ static void link_task_to_cpu(struct cpu_entry *entry, struct task_struct *task)
         for (; i < entry_level(entry) + 1; i++) {
                 ce = &entry->crit_entries[i];
                 if (!can_use(ce)) {
-                        TRACE_CRIT_ENTRY(ce, "CS_ACTIVATE\n");
                         ce->state = CS_ACTIVATE;
                 }
         }
@@ -462,7 +457,6 @@ static void update_crit_levels(struct cpu_entry *entry)
                  */
                 readmit[i] = (!global_preempted) ? ce->linked : NULL;
 
-                TRACE_CRIT_ENTRY(ce, "CS_REMOVE\n");
                 ce->state = CS_REMOVE;
                 if (ce->linked)
                         link_task_to_crit(ce, NULL);
@@ -479,22 +473,6 @@ static void update_crit_levels(struct cpu_entry *entry)
         }
 }
 
-static inline int cache_next(struct domain *dom)
-{
-        struct task_struct *t;
-        t = dom->peek_ready(dom);
-        return 1;
-        /* if (t && tsk_mc_crit(t) != CRIT_LEVEL_A && budget_exhausted(t)) { */
-        /*      TRACE_TASK(t, "Cached and moved to release\n"); */
-        /*      prepare_for_next_server(t, 1); */
-        /*      dom->take_ready(dom); */
-        /*      dom->requeue(dom, t); */
-        /*      return 0; */
-        /* } else { */
-        /*      return 1; */
-        /* } */
-}
-
 /**
  * check_for_preempt() - Causes a preemption if higher-priority tasks are ready.
  * Caller must hold domain lock.
@@ -513,10 +491,8 @@ static void check_for_preempt(struct domain *dom)
                         entry = crit_cpu(ce);
                         recheck = 1;
 
-                        /* Dodge exhausted tasks */
-                        if (!cache_next(dom)) {
-                                continue;
-                        }
+                        /* Cache next task */
+                        dom->peek_ready(dom);
 
                         raw_spin_lock(&entry->lock);
                         if (!can_use(ce))
@@ -535,8 +511,11 @@ static void check_for_preempt(struct domain *dom)
         } else /* Partitioned */ {
                 ce = domain_data(dom)->crit_entry;
                 entry = crit_cpu(ce);
+
+                /* Cache next task */
+                dom->peek_ready(dom);
+
                 raw_spin_lock(&entry->lock);
-                while (!cache_next(dom));
                 if (can_use(ce) && dom->preempt_needed(dom, ce->linked)) {
                         preempt(dom, ce);
                         update_crit_levels(entry);
@@ -552,7 +531,7 @@ static void check_for_preempt(struct domain *dom)
  */
 static void remove_from_all(struct task_struct* task)
 {
-        int update = 0, old;
+        int update = 0;
         struct cpu_entry *entry;
         struct crit_entry *ce;
         struct domain *dom = get_task_domain(task);
@@ -601,43 +580,38 @@ static void remove_from_all(struct task_struct* task)
  */
 static void job_completion(struct task_struct *task, int forced)
 {
-        lt_t now;
-        int ghost = is_ghost(task);
-        int behind = tsk_mc_crit(task) != CRIT_LEVEL_A && job_behind(task);
-        TRACE_MC_TASK(task, "Completed, ghost %d, forced %d, behind %d\n",
-                      ghost, forced, behind);
-
-        /* if (!is_ghost(task)) { */
-        /* and no more forced!!! */
-        if (!ghost && !forced)
-                sched_trace_task_completion(task, forced);
-        /* } */
-        BUG_ON(!task);
+        int behind;
+        TRACE_MC_TASK(task, "Completed\n");
 
         /* Logically stop the task execution */
         set_rt_flags(task, RT_F_SLEEP);
         remove_from_all(task);
 
-        now = litmus_clock();
-
+        /* Level-A tasks cannot ever get behind */
+        behind = tsk_mc_crit(task) != CRIT_LEVEL_A && behind_server(task);
 
-        if (!forced && !ghost) {
+        if (!forced && !is_ghost(task)) {
+                /* Task voluntarily ceased execution. Move on to next period */
                 task_release(task);
-        }
+                sched_trace_task_completion(task, forced);
 
-        if (!forced && !ghost) {
-                tsk_mc_data(task)->mc_job.ghost_budget =
-                        budget_remaining(task);
+                /* Convert to ghost job */
+                tsk_mc_data(task)->mc_job.ghost_budget = budget_remaining(task);
                 tsk_mc_data(task)->mc_job.is_ghost = 1;
         }
 
-        if (forced || behind || tsk_mc_data(task)->mc_job.ghost_budget == 0) {
-                TRACE_MC_TASK(task, "making not a ghost\n");
+        /* If the task has no ghost budget, convert back from ghost.
+         * If the task is behind, undo ghost conversion so that it
+         * can catch up.
+         */
+        if (behind || tsk_mc_data(task)->mc_job.ghost_budget == 0) {
+                TRACE_MC_TASK(task, "Not a ghost task\n");
                 tsk_mc_data(task)->mc_job.is_ghost = 0;
                 tsk_mc_data(task)->mc_job.ghost_budget = 0;
         }
 
-        if (forced || (!behind && !is_ghost(task))) {
+        /* If server has run out of budget, wait until next release */
+        if (budget_exhausted(task)) {
                 server_release(task);
         }
 
@@ -812,13 +786,8 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
         tsk_mc_data(t)->mc_job.is_ghost = 0;
         if (running) {
                 BUG_ON(entry->scheduled);
-                if (entry->cpu != FTRACE_CPU) {
-                        entry->scheduled = t;
-                        tsk_rt(t)->scheduled_on = entry->cpu;
-                } else {
-                        t->rt_param.scheduled_on = NO_CPU;
-                        preempt_if_preemptable(NULL, entry->cpu);
-                }
+                entry->scheduled = t;
+                tsk_rt(t)->scheduled_on = entry->cpu;
         } else {
                 t->rt_param.scheduled_on = NO_CPU;
         }
@@ -928,9 +897,6 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         int i, out_of_time, sleep, preempt, exists, blocks, global, lower;
         struct task_struct *dtask = NULL, *ready_task = NULL, *next = NULL;
 
-        if (entry->cpu == FTRACE_CPU)
-                return NULL;
-
         local_irq_save(flags);
 
         /* Litmus gave up because it couldn't access the stack of the CPU
@@ -1005,7 +971,6 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
                 raw_spin_lock(dom->lock);
 
                 /* Peek at task here to avoid lock use */
-                while (!cache_next(dom));
                 dtask = dom->peek_ready(dom);
 
                 raw_spin_lock(&entry->lock);
@@ -1100,7 +1065,6 @@ static long mc_activate_plugin(void)
         struct domain_data *dom_data;
         struct domain *dom;
         struct domain_data *our_domains[NR_CPUS];
-        struct event_group *event_group;
         int cpu, n = 0;
         long ret;
 
@@ -1196,9 +1160,7 @@ static void init_global_domain(struct domain_data *dom_data, enum crit_level lev
                 ce = &entry->crit_entries[level];
                 init_crit_entry(ce, level, dom_data, node);
                 bheap_node_init(&ce->node, ce);
-
-                if (cpu != FTRACE_CPU)
-                        bheap_insert(cpu_lower_prio, heap, node);
+                bheap_insert(cpu_lower_prio, heap, node);
         }
 }