Fixed accounting for empty container budget

1 files changed, 30 insertions, 27 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 449d6b3431a2..644c88c6c428 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -240,6 +240,7 @@ static noinline void unlink(struct task_struct* t)
                 entry = &per_cpu(edfsc_cpu_entries, t->rt_param.linked_on);

                 t->rt_param.linked_on = NO_CPU;

                 link_task_to_cpu(NULL, entry);

+        BUG_ON(entry->linked || t->rt_param.linked_on != NO_CPU);

         } else if (is_queued(t)) {

                 /* This is an interesting situation: t is scheduled,

                  * but was just recently unlinked.  It cannot be

@@ -444,9 +445,13 @@ static void g_finish_switch(struct task_struct *prev)
         cpu_entry_t*    entry = this_cpu_ptr(&edfsc_cpu_entries);

         BUG_ON(is_realtime(current) && tsk_rt(current)->domain == NULL);        

 

-        entry->scheduled = is_realtime(current) ? current : NULL;

-        if (entry->scheduled)

-                entry->scheduled = (is_fixed(current)) ? tsk_rt(current)->edfsc_params.container_task : current;

+    if (!is_container(entry->linked)) {

+            entry->scheduled = is_realtime(current) ? current : NULL;

+        if (entry->scheduled)

+                entry->scheduled = (is_fixed(current)) ? tsk_rt(current)->edfsc_params.container_task : current;

+    }

+    else

+        entry->scheduled = entry->linked;

 #ifdef WANT_ALL_SCHED_EVENTS

         TRACE_TASK(prev, "switched away from\n");

 #endif

@@ -587,17 +592,17 @@ void manage_idle_enforcement_timer(struct task_struct* t)
     lt_t now;

 

     cont_domain_t* domain = tsk_rt(t)->edfsc_params.domain;

-    if (t && budget_precisely_enforced(t)) {

+    now = litmus_clock();

+    domain->scheduled_last_exec_time = now;

+    if (budget_precisely_enforced(t)) {

         BUG_ON(budget_exhausted(t) && !is_np(t));

         if (likely(!is_np(t))) {

-            now = litmus_clock();

             //hrtimer_start cancels the timer so don't have to check

             //if it is already armed

             hrtimer_start(&(domain->idle_enforcement_timer),

                     ns_to_ktime(now + budget_remaining(t)),

                     HRTIMER_MODE_ABS_PINNED);

             domain->timer_armed = 1;

-            domain->scheduled_last_exec_time = now;

         }

     }

     else if (domain->timer_armed) {

@@ -620,21 +625,22 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
 

         /* sanity checking */

         BUG_ON(entry->scheduled && entry->scheduled != prev && !is_container(entry->scheduled));

-        BUG_ON(entry->scheduled && entry->scheduled != prev &&

+        BUG_ON(entry->scheduled && entry->scheduled != prev && is_realtime(prev) &&

                         tsk_rt(prev)->domain != tsk_rt(entry->scheduled)->edfsc_params.domain);

-        BUG_ON(entry->scheduled && entry->scheduled != prev &&

+        BUG_ON(entry->scheduled && entry->scheduled != prev && is_realtime(prev) && 

                         prev != tsk_rt(entry->scheduled)->edfsc_params.domain->scheduled);

         // It's okay for the previously scheduled task to not be rt if we think a

         // container task is scheduled and the container doesn't have any pending

         // jobs of fixed tasks.

-        BUG_ON(entry->scheduled && !is_realtime(prev));

+        BUG_ON(entry->scheduled && !is_container(entry->scheduled) && !is_realtime(prev));

         BUG_ON(is_realtime(prev) && !entry->scheduled);

 

     //TODO

     // condition when a container is "scheduled" but there are no realtime tasks

-    if (is_container(entry->scheduled) && (!prev || !is_realtime(prev)))

+    if (is_container(entry->scheduled) && (!prev || !is_realtime(prev))) {

         tsk_rt(entry->scheduled)->job_params.exec_time += litmus_clock()

             - tsk_rt(entry->scheduled)->edfsc_params.domain->scheduled_last_exec_time;

+    }

 

         // update container budget if prev was a fixed or background scheduled task

         if (entry->scheduled && prev && is_realtime(prev) && prev != entry->scheduled) {

@@ -653,7 +659,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         /* (0) Determine state */

         exists      = entry->scheduled != NULL;

         is_cont         = is_container(entry->scheduled);

-        blocks      = exists && !is_current_running();

+        blocks      = exists && !is_container(entry->scheduled) && !is_current_running();

         out_of_time = exists && budget_enforced(entry->scheduled)

                          && budget_exhausted(entry->scheduled);

         np              = exists && is_np(entry->scheduled);

@@ -677,7 +683,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
 

 

         /* If a task blocks we have no choice but to reschedule.

-         * Note: containers never block since their task struct has state = IS_RUNNING

+         * Note: containers never block

          */

         if (blocks)

                 unlink(entry->scheduled);

@@ -687,6 +693,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
          * that we are still linked. Multiple calls to request_exit_np() don't

          * hurt.

          */

+    printk("unlink? %d\n", np && (out_of_time || preempt || sleep));

         if (np && (out_of_time || preempt || sleep)) {

                 unlink(entry->scheduled);

                 request_exit_np(entry->scheduled);

@@ -697,6 +704,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
          * this. Don't do a job completion if we block (can't have timers running

          * for blocked jobs).

          */

+    printk("completion? %d\n", !np && (out_of_time || sleep));

         if (!np && (out_of_time || sleep))

                 g_job_completion(entry->scheduled, !sleep);

 

@@ -707,10 +715,9 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         printk("ready task in global domain %d\n", __peek_ready(&gsched_domain));

         if (__peek_ready(&gsched_domain))

                 printk("container id %d\n", tsk_rt(__peek_ready(&gsched_domain))->edfsc_params.id);

-        printk("%p\n", entry->linked);

         if (!entry->linked)

                 link_task_to_cpu(__take_ready(&gsched_domain), entry);

-        printk("%p\n", entry->linked);

+        printk("newly linked task: %p\n", entry->linked);

 

         /* The final scheduling decision. Do we need to switch for some reason?

          * If linked is different from scheduled, then select linked as next.

@@ -734,16 +741,14 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                 if (exists)

                         next = prev;

 

-        printk("%p\n", next);

-        printk("%p\n", tsk_rt(next)->domain);

-        printk("%p\n", &gsched_domain);

+        printk("next candidate: %p\n", next);

         if (is_container(next)) {

                 next = edfsc_cschedule(tsk_rt(next)->edfsc_params.domain, prev);

     }

 

         sched_state_task_picked();

 

-        printk("/edfsc_gschedule\n");

+        printk("/edfsc_gschedule\n\n");

 

         raw_spin_unlock_irqrestore(&g_lock, flags);

 

@@ -757,9 +762,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
 #endif

 

     if (is_container(next)) {

-        if (budget_precisely_enforced(next)) {

-            manage_idle_enforcement_timer(next);

-        }

+        manage_idle_enforcement_timer(next);

         return NULL;

     }

     else

@@ -785,7 +788,7 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
 

         raw_spin_lock_irqsave(&g_lock, flags);

 

-        printk("container_boundary\n");

+        printk("\ncontainer_boundary\n");

 

     now = litmus_clock();

 

@@ -906,12 +909,12 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                 if (budget_exhausted(t)) {

                         prepare_for_next_period(t);

                         if (is_early_releasing(t) || is_released(t, now)) {

+                //TODO actually release

                                 sched_trace_task_release(t);

             }

                         /* requeue

                          * But don't requeue a blocking task. */

                         if (is_current_running()) { //since we don't support blocking, this should always be true

-                printk("current: %d\n", current);

                                 if (tsk_rt(t)->edfsc_params.domain->scheduled) {

                                         requeue(tsk_rt(t)->edfsc_params.domain->scheduled);

                                 }

@@ -923,8 +926,8 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
             tsk_rt(&container_tasks[i])->edfsc_params.can_release = 1;

         }

         }

-        BUG();

-        printk("/container_boundary\n");

+

+        printk("/container_boundary\n\n");

         raw_spin_unlock_irqrestore(&g_lock, flags);

 

         hrtimer_add_expires_ns(timer, LITMUS_QUANTUM_LENGTH_NS);

@@ -1201,12 +1204,12 @@ static int __init init_edfsc(void)
 

         container_tasks[i].policy = SCHED_LITMUS;

                 tsk_rt(&container_tasks[i])->scheduled_on = NO_CPU;

-        tsk_rt(&container_tasks[i])->task_params.exec_cost = 0;

+        tsk_rt(&container_tasks[i])->task_params.exec_cost = LITMUS_QUANTUM_LENGTH_NS / 2;

         tsk_rt(&container_tasks[i])->task_params.period =

             LITMUS_QUANTUM_LENGTH_NS;

         tsk_rt(&container_tasks[i])->task_params.relative_deadline =

             LITMUS_QUANTUM_LENGTH_NS;

-        tsk_rt(&container_tasks[i])->task_params.budget_policy == PRECISE_ENFORCEMENT;

+        tsk_rt(&container_tasks[i])->task_params.budget_policy = PRECISE_ENFORCEMENT;

                 tsk_rt(&container_tasks[i])->edfsc_params.container_task = NULL;

         tsk_rt(&container_tasks[i])->domain = &gsched_domain;

                 tsk_rt(&container_tasks[i])->edfsc_params.domain = &container_domains[i];