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;
 
         raw_spin_lock_irqsave(&g_lock, flags);
 
@@ -727,11 +752,14 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                 TRACE_TASK(prev, "will be preempted by %s/%d\n",
                            entry->linked->comm, entry->linked->pid);
 
+        if (exists && preempted && !is_queued(entry->scheduled))
+                requeue(entry->scheduled);
 
         /* If a task blocks we have no choice but to reschedule.
          * Note: containers never block, so if blocks is true and we're background
          * scheduling, we want to unlink `prev` NOT `entry->scheduled`.
          */
+        if (blocks)
                 unlink(prev);
 
         /* Request a sys_exit_np() call if we would like to preempt but cannot.
@@ -811,9 +839,11 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
 
         // Tell LITMUS^RT that we choose a task and are done scheduling after return
         sched_state_task_picked();
+
         // When we transition from doing background scheduling to doing normal
         // scheduling, we may schedule the same task. Unfortunately, when this
         // happens, g_finish_switch() will /not/ be called. Fix the state manually.
+        temp = entry->scheduled;
         entry->scheduled = next;
 
         // if no fixed tasks to be scheduled by the container, then container->scheduled
@@ -824,6 +854,27 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                         manage_idle_enforcement_timer(next);
                 next = tsk_rt(next)->edfsc_params.domain->scheduled;
         }
+        // When next is migrating, but previously scheduled realtime task is a container
+        // must properly restore background scheduled task to its correct queue/heap
+        else if (is_container(temp) && next != temp) {
+                struct task_struct** child = &tsk_rt(temp)->edfsc_params.domain->scheduled;
+                // No need to handle fixed tasks, cschedule will do that when it runs next
+                if (*child && is_migrating(*child)) {
+                        BUG_ON(is_queued(*child));
+                        // If migrating and done
+                        if (is_completed(*child) || (budget_enforced(*child) && budget_exhausted(*child))) {
+                                g_job_completion(*child, budget_enforced(*child) && budget_exhausted(*child));
+                        // If migrating and blocked
+                        } else if (!is_current_running()) {
+                                unlink(*child);
+                        // Otherwise it can keep running globally
+                        } else {
+                                requeue(*child);
+                        }
+                        // Regardless, we never "freeze" a migrating task in a container
+                        *child = NULL;
+                }
+        }
 
         raw_spin_unlock_irqrestore(&g_lock, flags);
 
@@ -849,7 +900,6 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
         struct list_head *it;
         struct list_head *temp;
         u64 u_extra;
-        int need_reweight;
         cont_domain_t *container;
         struct task_struct *t;
         lt_t now;
@@ -898,7 +948,7 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                                 list_add(&t->edfsc_qnode, &migrating_tasks);
                         }
                         sys_util += get_rt_utilization(t);
-                        need_reweight = 1;
+                        sys_changed = 1;
                         // Setup the release time for the first job to be now
                         release_at(t, litmus_clock());
                 }
@@ -925,38 +975,40 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
         // We do this by adding a fake task that ultimately doesn't release any jobs
         // This is represented here by adding the utilization to sys_util
         // which will be subtracted when the migrating task is actually changed to fixed
-        list_for_each(it, &migrating_tasks) {
-                struct task_struct* t = task_of_list_node(it);
-                // Although technically selecting the migrating tasks to be moved into containers
-                // doesn't change m_util and the container's f_util until after the move,
-                // but since the move is guaranteed to happen before the next container_boundary
-                // where we check all the utilization stuff, it's fine to account for it now
-                if (!(tsk_rt(t)->edfsc_params.move_to) && !is_released(t, now)
+        if (sys_changed) {
+                list_for_each(it, &migrating_tasks) {
+                        struct task_struct* t = task_of_list_node(it);
+                        // Although technically selecting the migrating tasks to be moved into containers
+                        // doesn't change m_util and the container's f_util until after the move,
+                        // but since the move is guaranteed to happen before the next container_boundary
+                        // where we check all the utilization stuff, it's fine to account for it now
+                        if (!(tsk_rt(t)->edfsc_params.move_to) && !is_released(t, now)
                                 && get_deadline(t) < get_deadline(&container_tasks[0]) + get_rt_period(&container_tasks[0])) {
-                        tsk_rt(t)->edfsc_params.move_to = NULL;
-
-                        container = NULL;
-                        for (i = 0; i < num_cpus; i++) {
-                                u64 leftover = to_fp(1) - container_domains[i].f_util;
-                                if (leftover >= get_rt_utilization(t) && to_fp(num_cpus) >= get_rt_utilization(t) + sys_util) {
-                                        container = &(container_domains[i]);
-                                        break;
+                                tsk_rt(t)->edfsc_params.move_to = NULL;
+
+                                container = NULL;
+                                for (i = 0; i < num_cpus; i++) {
+                                        u64 leftover = to_fp(1) - container_domains[i].f_util;
+                                        if (leftover>=get_rt_utilization(t) && to_fp(num_cpus)>=get_rt_utilization(t)+sys_util) {
+                                                container = &(container_domains[i]);
+                                                break;
+                                        }
                                 }
-                        }
 
-                        if (container) {
-                                list_del_init(&t->edfsc_qnode);
-                                container->f_util += get_rt_utilization(t);
-                                m_util -= get_rt_utilization(t);
-                                sys_util += get_rt_utilization(t);
-                                tsk_rt(t)->edfsc_params.move_to = container;
-                                need_reweight = 1;
+                                if (container) {
+                                        list_del_init(&t->edfsc_qnode);
+                                        container->f_util += get_rt_utilization(t);
+                                        m_util -= get_rt_utilization(t);
+                                        sys_util += get_rt_utilization(t);
+                                        tsk_rt(t)->edfsc_params.move_to = container;
+                                        sys_changed = 1;
+                                }
                         }
                 }
         }
 
         // If needed, reweight containers using EqualOver heuristic
-        if (need_reweight) {
+        if (sys_changed) {
                 int remaining;
                 // Sort containers by the utilization of their fixed tasks
                 sort(container_list, num_cpus, sizeof(cont_domain_t *), &container_lower_prio, NULL);
@@ -985,6 +1037,7 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                         tsk_rt(t)->task_params.utilization = container_list[i]->f_util + u_extra / remaining;
                 }
         }
+        sys_changed = 0;
 
         INIT_LIST_HEAD(&pending_adds);
 
@@ -1016,6 +1069,7 @@ static enum hrtimer_restart task_deadline_callback(struct hrtimer* timer) {
         struct task_struct *t = container_of(timer, struct task_struct, edfsc_deadline_timer);
 
         BUG_ON(is_container(t));
+        printk("util: %d\n", sys_util);
         // This is true only if set to be migrating from container_boundary
         if (tsk_rt(t)->edfsc_params.move_to) {
                 // Migrate here if the task is not late, otherwise migrate in job_complete
@@ -1328,6 +1382,7 @@ static int __init init_edfsc(void)
 
         sys_util = to_fp(0);
         m_util = to_fp(0);
+        sys_changed = 1;
 
         memset(container_tasks, 0, sizeof(struct task_struct) * num_online_cpus());
         memset(container_domains, 0, sizeof(cont_domain_t) * num_online_cpus());