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());