Merge branch 'wip-mc' of ssh://cvs.cs.unc.edu/cvs/proj/litmus/repo/litmus2010 into wip-mc

Conflicts:
	litmus/sched_mc.c

4 files changed, 59 insertions, 101 deletions

diff --git a/include/litmus/budget.h b/include/litmus/budget.h
index 062df818de45..ff18d89e8630 100644
--- a/include/litmus/budget.h
+++ b/include/litmus/budget.h
@@ -1,15 +1,35 @@
 #ifndef _LITMUS_BUDGET_H_
 #define _LITMUS_BUDGET_H_
 
-/* Update the per-processor enforcement timer (arm/reproram/cancel) for
- * the next task. */
+/**
+ * update_enforcement_timer() - Update per-processor enforcement timer for
+ * the next scheduled task.
+ *
+ * If @t is not NULL and has a precisely enforced budget, the timer will be
+ * armed to trigger a reschedule when the budget is exhausted. Otherwise,
+ * the timer will be cancelled.
+*/
 void update_enforcement_timer(struct task_struct* t);
 
-void prepare_for_next_server(struct task_struct* t,int forced);
-
-#define job_behind(t)\
+/* True if a task's server has progressed farther than the task
+ * itself. This happens when budget enforcement has caused a task to be
+ * booted off until the next period.
+ */
+#define behind_server(t)\
         (lt_before((t)->rt_param.job_params.real_release, get_release(t)))
 
+/**
+ * server_release() - Prepare the task server parameters for the next period.
+ * The server for @t is what is actually executed from the schedulers
+ * perspective.
+ */
 void server_release(struct task_struct *t);
+
+/**
+ * task_release() - Prepare actual task parameters for the next period.
+ * The actual task parameters for @t, real_deadline and real_release, are
+ * the deadline and release from the tasks perspective. We only record these
+ * so that we can write them to feather trace.
+ */
 void task_release(struct task_struct *t);
 #endif
diff --git a/litmus/budget.c b/litmus/budget.c
index b2239ff1c45c..93945e0911a7 100644
--- a/litmus/budget.c
+++ b/litmus/budget.c
@@ -64,7 +64,7 @@ static void arm_enforcement_timer(struct enforcement_timer* et,
 
         /* Calling this when there is no budget left for the task
          * makes no sense, unless the task is non-preemptive. */
-        /* BUG_ON(budget_exhausted(t) && (!is_np(t))); */
+        BUG_ON(budget_exhausted(t) && (!is_np(t)));
 
         /* __hrtimer_start_range_ns() cancels the timer
          * anyway, so we don't have to check whether it is still armed */
@@ -115,9 +115,6 @@ void task_release(struct task_struct *t)
         t->rt_param.job_params.real_release = t->rt_param.job_params.real_deadline;
         t->rt_param.job_params.real_deadline += get_rt_period(t);
         t->rt_param.job_params.job_no++;
-        TRACE_TASK(t, "Releasing task, rr=%llu rd=%llu\n",
-                   t->rt_param.job_params.real_release,
-                   t->rt_param.job_params.real_deadline);
         sched_trace_task_release(t);
 }
 
@@ -127,22 +124,8 @@ void server_release(struct task_struct *t)
         t->rt_param.job_params.exec_time = 0;
         t->rt_param.job_params.release = t->rt_param.job_params.deadline;
         t->rt_param.job_params.deadline +=  get_rt_period(t);
-        TRACE_TASK(t, "Releasing server, r=%llu d=%llu\n",
-                   t->rt_param.job_params.release,
-                   t->rt_param.job_params.deadline);
         /* don't confuse linux */
         t->rt.time_slice = 1;
 }
 
-void prepare_for_next_server(struct task_struct *t, int forced)
-{
-        if (forced || job_behind(t)) {
-                server_release(t);
-        }
-
-        if (!forced) {
-                task_release(t);
-        }
-}
-
 module_init(init_budget_enforcement);
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index b615092ce9c9..3b3b49ed48ea 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -261,7 +261,6 @@ static void setup_release(rt_domain_t *_rt)
         list_for_each_safe(pos, safe, &list) {
                 /* pick task of work list */
                 t = list_entry(pos, struct task_struct, rt_param.list);
-                /* sched_trace_task_release(t); */
                 list_del_init(pos);
 
                 /* put into release heap while holding release_lock */
@@ -412,24 +411,19 @@ static void pd_requeue(domain_t *dom, struct task_struct *task)
 {
         rt_domain_t *domain = (rt_domain_t*)dom->data;
 
-        BUG_ON(!task || !is_realtime(task));
         TRACE_TASK(task, "Requeueing\n");
+        BUG_ON(!task || !is_realtime(task));
         BUG_ON(is_queued(task));
         BUG_ON(get_task_domain(task) != dom);
 
-        if (is_queued(task)) {
-                VTRACE_TASK(task, "Queued, skipping\n");
-                return;
-        }
-
         if (is_released(task, litmus_clock())) {
                 __add_ready(domain, task);
-                VTRACE("going, rt: adding %s/%d (%llu, %llu) rel=%llu to ready queue at %llu\n",
+                VTRACE("rt: adding %s/%d (%llu, %llu) rel=%llu to ready queue at %llu\n",
                       task->comm, task->pid, get_exec_cost(task), get_rt_period(task),
                       get_release(task), litmus_clock());
         } else {
                 /* task has to wait for next release */
-                VTRACE_TASK(task, "not going, add release(), rel=%llu\n", get_release(task));
+                VTRACE_TASK(task, "add release(), rel=%llu\n", get_release(task));
                 add_release(domain, task);
         }
 
@@ -441,9 +435,8 @@ static void pd_requeue(domain_t *dom, struct task_struct *task)
  */
 static struct task_struct* pd_take_ready(domain_t *dom)
 {
-        struct task_struct *t = __take_ready((rt_domain_t*)dom->data);
-        return t;
-}
+        return __take_ready((rt_domain_t*)dom->data);
+ }
 
 /* pd_peek_ready - returns the head of the rt_domain ready queue
  *
@@ -451,8 +444,7 @@ static struct task_struct* pd_take_ready(domain_t *dom)
  */
 static struct task_struct* pd_peek_ready(domain_t *dom)
 {
-        struct task_struct *t = __peek_ready((rt_domain_t*)dom->data);
-        return t;
+        return  __next_ready((rt_domain_t*)dom->data);
 }
 
 static void pd_remove(domain_t *dom, struct task_struct *task)
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 5eaaa4734fa3..5700d21250d2 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -104,8 +104,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)))
@@ -194,11 +192,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);
                 }
         }
@@ -433,7 +429,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;
                 }
         }
@@ -505,7 +500,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);
@@ -522,22 +516,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.
@@ -556,10 +534,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))
@@ -578,8 +554,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);
@@ -595,7 +574,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);
@@ -644,43 +623,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);
         }
 
@@ -855,13 +829,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;
         }
@@ -971,9 +940,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
@@ -1143,7 +1109,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;
 
@@ -1239,9 +1204,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);
         }
 }