Fixed contain domain->scheduled tracking

scheduled for container domains is now set to null when container is preempted

1 files changed, 24 insertions, 11 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 754891b8c12f..10ebf7c098f4 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -66,7 +66,6 @@ u64 sys_util, future_sys_util;
 
 #define is_container(task) ((task) && tsk_rt(task)->edfsc_params.domain != NULL && tsk_rt(task)->domain == &gsched_domain)
 #define is_fixed(task) ((task) && tsk_rt(task)->edfsc_params.container_task != NULL)
-//migrating task can temporarily have a container_task when it is being background scheduled
 #define is_migrating(task) ((task) && tsk_rt(task)->edfsc_params.domain == NULL && tsk_rt(task)->domain == &gsched_domain)
 
 #define FP_SHIFT 20
@@ -527,13 +526,15 @@ static void c_job_completion(struct task_struct* t, int forced)
 static void g_finish_switch(struct task_struct *prev)
 {
         cpu_entry_t* entry = this_cpu_ptr(&edfsc_cpu_entries);
+        struct task_struct* container = &container_tasks[entry->cpu];
         BUG_ON(is_realtime(current) && tsk_rt(current)->domain == NULL);
+        //BUG_ON(tsk_rt(container)->scheduled_on != smp_processor_id());
 
         entry->scheduled = is_realtime(current) ? current : NULL;
+        // If we're scheduling a task in a container, set entry->scheduled to the container
         if (entry->scheduled) {
-                // when a task is being scheduled under a container, container_task exists
-                struct task_struct* t = tsk_rt(current)->edfsc_params.container_task;
-                entry->scheduled = (t) ? t : current;
+                if (tsk_rt(container)->edfsc_params.domain->scheduled == entry->scheduled)
+                        entry->scheduled = container;
         }
         // occurs when current is non-rt, and linked is a container
         // this happens when an empty container "task" is supposed to be current
@@ -541,6 +542,11 @@ static void g_finish_switch(struct task_struct *prev)
         else if (is_container(entry->linked)) {
                 entry->scheduled = entry->linked;
         }
+
+        if (!is_container(entry->scheduled) && tsk_rt(container)->edfsc_params.domain->scheduled) {
+                requeue(tsk_rt(container)->edfsc_params.domain->scheduled);
+                tsk_rt(container)->edfsc_params.domain->scheduled = NULL;
+        }
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE_TASK(prev, "switched away from\n");
 #endif
@@ -573,8 +579,7 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
          * cedf->schedule may be null and prev _is_ realtime
          */
         BUG_ON(cedf->scheduled && cedf->scheduled != prev && is_realtime(prev));
-        // XXX: Is this okay with background scheduling???
-        BUG_ON(cedf->scheduled && is_migrating(cedf->scheduled));
+        BUG_ON(cedf->scheduled && !is_realtime(cedf->scheduled));
 
         /* (0) Determine state */
         exists    = cedf->scheduled != NULL;
@@ -627,12 +632,13 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
                  * the appropriate queue.
                  */
                 next = __take_ready(edf);
-        } else
+        } else if (exists) {
+                BUG_ON(!is_realtime(prev));
                 /* Only override Linux scheduler if we have a real-time task
                  * scheduled that needs to continue.
                  */
-                if (exists)
-                        next = prev;
+                next = prev;
+        }
 
         if (next) {
                 TRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
@@ -772,6 +778,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
 
         BUG_ON(entry->linked && budget_exhausted(entry->linked));
         BUG_ON(!bheap_node_in_heap(entry->hn) && tsk_rt(entry->linked)->edfsc_params.id != entry->cpu);
+        BUG_ON(is_container(entry->linked) && tsk_rt(entry->linked)->edfsc_params.id != entry->cpu);
 
         /* The final scheduling decision. Do we need to switch for some reason?
          * If linked is different from scheduled, then select linked as next.
@@ -815,9 +822,9 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         if (is_container(next)) {
                 manage_idle_enforcement_timer(next);
                 return tsk_rt(next)->edfsc_params.domain->scheduled;
-        }
-        else
+        } else {
                 return next;
+        }
 }
 
 /*
@@ -843,6 +850,7 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
 
         now = litmus_clock();
 
+        // Update budget tracking for containers
         for (i = 0; i < num_cpus; i++) {
                 t = container_list[i]->container;
                 if (container_list[i]->timer_armed)
@@ -884,6 +892,8 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                         sys_util += get_rt_utilization(t);
                         future_sys_util += get_rt_utilization(t);
                         need_reweight = 1;
+                        // Setup the release time for the first job to be now
+                        release_at(t, litmus_clock());
                 }
                 list_del(it);
                 /* Unblock the task waiting on our admission decision. They will detect
@@ -1060,6 +1070,9 @@ static void edfsc_task_new(struct task_struct* t, int on_rq, int is_scheduled)
 
                 // Run the scheduler to make sure that this should be running
                 preempt(entry);
+        } else {
+                // If we're not scheduled, we should be queued
+                requeue(t);
         }
 
         // XXX: This seems unnecessary and possibly dangerous if `is_scheduled`