Final Fixes

Fixed jobs sometimes disappearing due to mysterious path in gschedule
where it is not requeued. This is done by first requeueing regardless,
and letting unlink dequeue as necessary.

Made container_boundary only try to stabilize when new tasks are
removed/added to the systed

2 files changed, 99 insertions, 39 deletions

diff --git a/litmus/litmus_proc.c b/litmus/litmus_proc.c
index de5e3f37fe88..ebea92da0a3d 100644
--- a/litmus/litmus_proc.c
+++ b/litmus/litmus_proc.c
@@ -31,13 +31,18 @@ static struct proc_dir_entry *litmus_dir = NULL,
 /* in litmus/sync.c */
 int count_tasks_waiting_for_release(void);
 
+/* in litmus/sched_edfsc.c */
+int count_migrating_tasks(void);
+
 static int litmus_stats_proc_show(struct seq_file *m, void *v)
 {
         seq_printf(m,
                    "real-time tasks   = %d\n"
-                   "ready for release = %d\n",
+                   "ready for release = %d\n"
+                   "migrating tasks   = %d\n",
                    atomic_read(&rt_task_count),
-                   count_tasks_waiting_for_release());
+                   count_tasks_waiting_for_release(),
+                   count_migrating_tasks());
         return 0;
 }
 
diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 8ae94f2dc1df..fae6feeac76f 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -68,6 +68,9 @@ static rt_domain_t gsched_domain;
 u64 m_util;
 u64 sys_util;
 
+//only true when container_boundary needs to perform stabilization
+int sys_changed;
+
 #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)
 #define is_migrating(task) ((task) && tsk_rt(task)->edfsc_params.domain == NULL && tsk_rt(task)->domain == &gsched_domain)
@@ -83,6 +86,21 @@ void release_heap_free(struct release_heap* rh);
 struct bheap_node* bheap_node_alloc(int gfp_flags);
 void bheap_node_free(struct bheap_node* hn);
 
+int count_migrating_tasks(void)
+{
+        int task_count = 0;
+        struct list_head *pos;
+        unsigned long flags;
+
+        raw_spin_lock_irqsave(&g_lock, flags);
+
+        list_for_each(pos, &migrating_tasks) {
+                task_count++;
+        }
+
+        raw_spin_unlock_irqrestore(&g_lock, flags);
+        return task_count;
+}
 
 /* Do a backwards comparison based on f_util so that heavier containers
  * will come first
@@ -370,6 +388,7 @@ static void g_remove_task(struct task_struct *t)
         BUG_ON(is_container(t));
         m_util -= get_rt_utilization(t);
         sys_util -= get_rt_utilization(t);
+        sys_changed = 1;
 }
 
 static void c_remove_task(struct task_struct *t)
@@ -378,6 +397,7 @@ static void c_remove_task(struct task_struct *t)
         tsk_rt(container_task)->edfsc_params.domain->f_util -=
                 get_rt_utilization(t);
         sys_util -= get_rt_utilization(t);
+        sys_changed = 1;
 }
 
 /**
@@ -400,6 +420,7 @@ static void migrate_task(struct task_struct *t)
         tsk_rt(t)->edfsc_params.container_task = tsk_rt(t)->edfsc_params.move_to->container;
         requeue(t);
         tsk_rt(t)->edfsc_params.move_to = NULL;
+        sys_changed = 1;
 }
 
 /**
@@ -492,6 +513,7 @@ static noinline void g_job_completion(struct task_struct* t, int forced)
          * tardy case, then just immediately call c_release() on the container.
          */
         } else if (is_container(t)) {
+                /*
                 struct task_struct** child = &tsk_rt(t)->edfsc_params.domain->scheduled;
                 // No need to handle fixed tasks, cschedule will do that when it runs next
                 if (*child && is_migrating(*child)) {
@@ -509,6 +531,7 @@ static noinline void g_job_completion(struct task_struct* t, int forced)
                         // Regardless, we never "freeze" a migrating task in a container
                         *child = NULL;
                 }
+                */
                 // When a container job finishes late, release it immediately
                 if (tsk_rt(t)->edfsc_params.can_release) {
                         tsk_rt(t)->edfsc_params.can_release = 0;
@@ -543,7 +566,8 @@ static void g_finish_switch(struct task_struct *prev)
         //        members of entry multiple times, we have to lock. Otherwise we
         //        may make an if branch based off entry->linked, and then have it
         //        change before we can set entry->scheduled.
-        raw_spin_lock_irqsave(&g_lock, flags);
+        //raw_spin_lock_irqsave(&g_lock, flags);
+        preempt_disable();
         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) {
@@ -557,13 +581,9 @@ static void g_finish_switch(struct task_struct *prev)
                 entry->scheduled = entry->linked;
         }
 
-        // This handles requeuing when a container is descheduled
-        // TODO: Move this to edfsc_gschedule()
-        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;
-        }
-        raw_spin_unlock_irqrestore(&g_lock, flags);
+        BUG_ON(is_fixed(entry->scheduled));
+        //raw_spin_unlock_irqrestore(&g_lock, flags);
+        preempt_enable();
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE_TASK(prev, "switched away from\n");
 #endif
@@ -595,7 +615,7 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
          * differently from gedf, when a task exits (dead)
          * cedf->schedule may be null and prev _is_ realtime
          */
-        BUG_ON(cedf->scheduled && cedf->scheduled != prev && is_realtime(prev));
+        //BUG_ON(cedf->scheduled && cedf->scheduled != prev && is_realtime(prev));
         BUG_ON(cedf->scheduled && !is_realtime(cedf->scheduled));
 
         /* (0) Determine state */
@@ -605,7 +625,8 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
                                          && budget_exhausted(cedf->scheduled);
         np              = exists && is_np(cedf->scheduled);
         sleep           = exists && is_completed(cedf->scheduled);
-        preempt         = (is_migrating(prev) && __peek_ready(edf)) || edf_preemption_needed(edf, prev);
+        preempt         = (is_migrating(cedf->scheduled) && __peek_ready(edf)) ||
+                                        (exists && edf_preemption_needed(edf, cedf->scheduled));
 
         /* If we need to preempt do so.
          * The following checks set resched to 1 in case of special
@@ -632,7 +653,7 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
         }
 
         // Deschedule any background jobs if a fixed task is ready
-        if (is_migrating(cedf->scheduled) && preempt) {
+        if (is_migrating(cedf->scheduled) || preempt) {
                 if (!sleep && !out_of_time && !blocks && !is_queued(cedf->scheduled))
                         requeue(cedf->scheduled);
                 resched = 1;
@@ -644,6 +665,9 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
          */
         next = NULL;
         if (blocks || !exists || (!np && resched)) {
+                /*if (exists && !out_of_time && !sleep && !is_queued(cedf->scheduled)) {
+                        requeue(cedf->scheduled);
+                }*/
                 next = __take_ready(edf);
         } else if (exists) {
                 // This is safe when background scheduling, as we can only get here if
@@ -682,6 +706,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         int out_of_time, sleep, preempted, np, exists, blocks, is_cont;
         unsigned long flags;
         struct task_struct* next = NULL;
+        struct task_struct* temp = NULL;