Moved budget accounting into MC plugin.

This commit is broken as it allows locking tasks to early release.

1 files changed, 19 insertions, 42 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 76479fd08d3a..3fb223255792 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -281,21 +281,19 @@ static inline void start_crit(struct crit_entry *ce)
  * Time accounting for ghost tasks.
  * Must be called before a decision is made involving the task's budget.
  */
-static void update_ghost_time(struct task_struct *p)
+static void update_server_time(struct task_struct *p)
 {
         u64 clock = litmus_clock();
-        u64 delta = clock - p->se.exec_start;
-        BUG_ON(!is_ghost(p));
+        u64 delta = clock - p->rt_param.last_exec_time;
         if (unlikely ((s64)delta < 0)) {
                 delta = 0;
         }
         if (budget_remaining(p) <= delta) {
                 tsk_rt(p)->job_params.exec_time = get_exec_cost(p);
-                p->se.exec_start = clock;
         } else {
                 tsk_rt(p)->job_params.exec_time += delta;
-                p->se.exec_start = clock;
         }
+        p->rt_param.last_exec_time = clock;
 }
 
 /**
@@ -305,8 +303,6 @@ static void update_ghost_time(struct task_struct *p)
 static void link_task_to_crit(struct crit_entry *ce,
                               struct task_struct *task)
 {
-        lt_t when_to_fire;
-
         TRACE_CRIT_ENTRY(ce, "Linking " TS "\n", TA(task));
         BUG_ON(!can_use(ce) && task);
         BUG_ON(task && tsk_rt(task)->linked_on != NO_CPU);
@@ -323,7 +319,7 @@ static void link_task_to_crit(struct crit_entry *ce,
                         cancel_ghost(ce);
                         if (!budget_exhausted(ce->linked)) {
                                 /* Job isn't finished, so do accounting */
-                                update_ghost_time(ce->linked);
+                                update_server_time(ce->linked);
                         }
                 }
                 sched_trace_server_switch_away(ce_sid(ce), 0, -ce->linked->pid,
@@ -683,6 +679,7 @@ static void job_completion(struct task_struct *task, int forced)
         TRACE_MC_TASK(task, "Completed\n");
 
         /* Logically stop the task execution */
+        remove_from_all(task);
         set_rt_flags(task, RT_F_SLEEP);
 
         if (!forced) {
@@ -715,15 +712,10 @@ static void job_completion(struct task_struct *task, int forced)
                 set_rt_flags(task, RT_F_RUNNING);
         }
 
-        /* If the server was not released, then the task's priority remains
-         * unchanged and it should be left where it is
-         */
-        if (release_server) {
-                remove_from_all(task);
-                if (is_running(task)) {
-                        /* Requeue non-blocking tasks */
-                        job_arrival(task);
-                }
+
+        if (is_running(task)) {
+                /* Requeue non-blocking tasks */
+                job_arrival(task);
         }
 }
 
@@ -739,31 +731,10 @@ static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
 {
         struct crit_entry *ce = container_of(timer, struct crit_entry, timer);
 #endif
-
-        unsigned long flags;
-        struct task_struct *tmp = NULL;
-
-        local_irq_save(flags);
         TRACE_CRIT_ENTRY(ce, "Firing here at %llu\n", litmus_clock());
 
-        /* Due to race conditions, we cannot just set the linked
-         * task's budget to 0 as it may no longer be the task
-         * for which this timer was armed. Instead, update the running
-         * task time and see if this causes exhaustion.
-         */
-        raw_spin_lock(&crit_cpu(ce)->lock);
-        if (ce->linked && is_ghost(ce->linked)) {
-                update_ghost_time(ce->linked);
-                if (budget_exhausted(ce->linked)) {
-                        tmp = ce->linked;
-                }
-        }
-        raw_spin_unlock(&crit_cpu(ce)->lock);
-
-        if (tmp)
-                job_completion(tmp, 1);
+        litmus_reschedule(crit_cpu(ce)->cpu);
 
-        local_irq_restore(flags);
 #ifndef CONFIG_MERGE_TIMERS
         return HRTIMER_NORESTART;
 #endif
@@ -924,6 +895,7 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
                 BUG_ON(entry->scheduled);
                 entry->scheduled = t;
                 tsk_rt(t)->scheduled_on = entry->cpu;
+                tsk_rt(t)->last_exec_time = litmus_clock();
         } else {
                 t->rt_param.scheduled_on = NO_CPU;
         }
@@ -1101,6 +1073,11 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         BUG_ON(entry->scheduled && !is_realtime(prev));
         BUG_ON(is_realtime(prev) && !entry->scheduled);
 
+        if (entry->scheduled != NULL) {
+                prev->rt_param.scheduled_on = NO_CPU;
+                update_server_time(prev);
+        }
+
         /* Determine state */
         exists      = entry->scheduled != NULL;
         blocks      = exists && !is_running(entry->scheduled);
@@ -1114,8 +1091,6 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         TRACE(TS " block:%d oot:%d sleep:%d preempt:%d, now: %llu\n",
               TA(prev), blocks, out_of_time, sleep, preempt, litmus_clock());
 
-        if (exists)
-                prev->rt_param.scheduled_on = NO_CPU;
 
         raw_spin_unlock(&entry->lock);
 
@@ -1169,7 +1144,9 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         raw_spin_unlock_irqrestore(&entry->lock, flags);
 
         if (next) {
-                BUG_ON(!is_released(next, litmus_clock()));
+                tsk_rt(next)->last_exec_time = litmus_clock();
+                BUG_ON(!is_released(next, tsk_rt(next)->last_exec_time));
+                BUG_ON(is_ghost(next));
                 TRACE_MC_TASK(next, "Picked this task\n");
         } else if (exists && !next)
                 STRACE("CPU %d becomes idle at %llu\n",