Fixed calling link_task_to_cpu causing a BUG_ON

This happens because we're not properly scheduling containers to their
associated cores and we're not properly keeping track of cpus whose
containers are fully provisioned.
I fixed the logic for that.

Also, I moved around some functions to group them by similar usage and
fixed some minor bugs

1 files changed, 140 insertions, 66 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index ea1b308667c7..a787fd5a040d 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -156,14 +156,77 @@ static cpu_entry_t* lowest_prio_cpu(void)
         return hn->value;
 }
 
+static void remove_cpu_from_global(cpu_entry_t *entry)
+{
+        bheap_delete(cpu_lower_prio, &edfsc_cpu_heap, entry->hn);
+}
+
+static void add_cpu_to_global(cpu_entry_t *entry)
+{
+        bheap_insert(cpu_lower_prio, &edfsc_cpu_heap, entry->hn);
+}
+
 /* update_cpu_position - Move the cpu entry to the correct place to maintain
  *                                         order in the cpu queue. Caller must hold g_lock.
  */
 static void update_cpu_position(cpu_entry_t *entry)
 {
         if (likely(bheap_node_in_heap(entry->hn)))
-                bheap_delete(cpu_lower_prio, &edfsc_cpu_heap, entry->hn);
-        bheap_insert(cpu_lower_prio, &edfsc_cpu_heap, entry->hn);
+                remove_cpu_from_global(entry);
+        add_cpu_to_global(entry);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+/*
+ *
+ * IDLE CONTAINER BUDGET ENFORCEMENT
+ *
+ */
+
+//timeout for timer enforcing budget of empty container
+static enum hrtimer_restart on_idle_enforcement_timeout(struct hrtimer *timer)
+{
+        cont_domain_t* domain = container_of(timer, cont_domain_t, idle_enforcement_timer);
+
+        unsigned long flags;
+
+        local_irq_save(flags);
+        domain->timer_armed = 0;
+        litmus_reschedule_local();
+        local_irq_restore(flags);
+
+        return HRTIMER_NORESTART;
+}
+
+void manage_idle_enforcement_timer(struct task_struct* t)
+{
+        lt_t now;
+
+        cont_domain_t* domain = tsk_rt(t)->edfsc_params.domain;
+        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))) {
+                        //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;
+                }
+        }
+        else if (domain->timer_armed) {
+                hrtimer_try_to_cancel(&(domain->idle_enforcement_timer));
+                domain->timer_armed = 0;
+        }
+}
+
+void cancel_idle_enforcement_timer(struct task_struct* t)
+{
+        cont_domain_t* domain = tsk_rt(t)->edfsc_params.domain;
+        hrtimer_try_to_cancel(&(domain->idle_enforcement_timer));
+        domain->timer_armed = 0;
 }
 
 /* link_task_to_cpu - Links a migrating task or container to a CPU
@@ -277,9 +340,8 @@ static void g_preempt_check(void)
                 edf_preemption_needed(&gsched_domain, last->linked);
                 last = lowest_prio_cpu()) {
                 target = last;
-                if (is_container(last->linked) && get_rt_utilization(last->linked) == to_fp(1)) {
-                        break;
-                }
+                BUG_ON(is_container(last->linked) && get_rt_utilization(last->linked) == to_fp(1));
+
                 /* preemption necessary */
                 task = __take_ready(&gsched_domain);
                 if (is_container(task)) {
@@ -340,6 +402,7 @@ static void g_remove_task(struct task_struct *t)
         future_m_util -= get_rt_utilization(t);
         future_sys_util -= get_rt_utilization(t);
         if (tsk_rt(t)->edfsc_params.move_to) {
+                prepare_for_next_period(t);
                 tsk_rt(t)->domain = (rt_domain_t*)tsk_rt(t)->edfsc_params.move_to;
                 tsk_rt(t)->edfsc_params.container_task = tsk_rt(t)->edfsc_params.move_to->container;
                 requeue(t);
@@ -376,6 +439,8 @@ static noinline void g_job_completion(struct task_struct* t, int forced)
         BUG_ON(!t);
         sched_trace_task_completion(t, forced);
 
+        cpu_entry_t* entry;
+
         TRACE_TASK(t, "job_completion(forced=%d).\n", forced);
 
         /* set flags */
@@ -384,31 +449,55 @@ static noinline void g_job_completion(struct task_struct* t, int forced)
         /* unlink */
         unlink(t);
 
+        // When migrating is being removed, or turned into a fixed task
         if (is_migrating(t) && tsk_rt(t)->edfsc_params.will_remove) {
                 if (t->rt_param.job_params.lateness > 0) {
                         // remove the task now
                         if (is_queued(t))
                                 remove(tsk_rt(t)->domain, t);
+                        //g_remove_task will properly add t to the move_to container
                         g_remove_task(t);
                 }
-        } else if (is_migrating(t) || (is_container(t) && tsk_rt(t)->edfsc_params.can_release)) {
-                tsk_rt(t)->edfsc_params.can_release = 0; //only matter for containers
+                else {
+                        //TODO: deadline timer to call g_remove_task
+                }
+        // When a migrating job finishes
+        } else if (is_migrating(t)) {
                 /* prepare for next period */
-                tsk_rt(t)->task_params.exec_cost = from_fp(get_rt_utilization(t) * get_rt_period(t));
                 prepare_for_next_period(t);
                 if (is_early_releasing(t) || is_released(t, litmus_clock()))
                         sched_trace_task_release(t);
-                        //TODO
                 /* requeue
                  * But don't requeue a blocking task. */
                 if (is_current_running()) { //since we don't support blocking, this should always be true
-                        if (is_container(t) && tsk_rt(t)->edfsc_params.domain->scheduled) {
-                                requeue(tsk_rt(t)->edfsc_params.domain->scheduled);
-                                tsk_rt(t)->edfsc_params.domain->scheduled = NULL;
-                        }
                         requeue(t);
                         g_preempt_check();
                 }
+        // When a container job finishes late
+        } else if (is_container(t) && tsk_rt(t)->edfsc_params.can_release) {
+                tsk_rt(t)->edfsc_params.can_release = 0;
+                tsk_rt(t)->task_params.exec_cost = from_fp(get_rt_utilization(t) * get_rt_period(t));
+                prepare_for_next_period(t);
+                if (is_early_releasing(t) || is_released(t, litmus_clock()))
+                        sched_trace_task_release(t);
+                if (get_rt_utilization(t) == to_fp(1)) {
+                        cpu_entry_t* entry = &per_cpu(edfsc_cpu_entries, tsk_rt(t)->edfsc_params.id);
+                        remove_cpu_from_global(entry);
+                        entry->linked = t;
+                        tsk_rt(t)->linked_on = entry->cpu;
+                        cancel_idle_enforcement_timer(t);
+                        preempt(entry);
+                }
+                else {
+                        if (is_current_running()) {
+                                if (tsk_rt(t)->edfsc_params.domain->scheduled) {
+                                        requeue(tsk_rt(t)->edfsc_params.domain->scheduled);
+                                        tsk_rt(t)->edfsc_params.domain->scheduled = NULL;
+                                }
+                                requeue(t);
+                                g_preempt_check();
+                        }
+                }
         }
 }
 
@@ -573,35 +662,12 @@ static struct task_struct* edfsc_cschedule(cont_domain_t* cedf, struct task_stru
         return (next) ? next : cedf->container;
 }
 
-void manage_idle_enforcement_timer(struct task_struct* t)
-{
-        lt_t now;
-
-        cont_domain_t* domain = tsk_rt(t)->edfsc_params.domain;
-        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))) {
-                        //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;
-                }
-        }
-        else if (domain->timer_armed) {
-                hrtimer_try_to_cancel(&(domain->idle_enforcement_timer));
-                domain->timer_armed = 0;
-        }
-}
 
 //assuming prev is previous task running on the processor before calling schedule
 static struct task_struct *edfsc_gschedule(struct task_struct *prev)
 {
         cpu_entry_t* entry = this_cpu_ptr(&edfsc_cpu_entries);
-        int out_of_time, sleep, preempt, np, exists, blocks, is_cont;
+        int out_of_time, sleep, preempted, np, exists, blocks, is_cont;
         struct task_struct* next = NULL;
         unsigned long flags;
 
@@ -650,7 +716,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                                                  && budget_exhausted(entry->scheduled);
         np                      = exists && is_np(entry->scheduled);
         sleep           = exists && is_completed(entry->scheduled);
-        preempt  = entry->scheduled != entry->linked;
+        preempted        = entry->scheduled != entry->linked;
 
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE_TASK(prev, "invoked gsnedf_schedule.\n");
@@ -663,7 +729,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                            blocks, out_of_time, np, sleep, preempt,
                            prev->state, signal_pending(prev), is_cont);
 
-        if (entry->linked && preempt)
+        if (entry->linked && preempted)
                 TRACE_TASK(prev, "will be preempted by %s/%d\n",
                            entry->linked->comm, entry->linked->pid);
 
@@ -679,7 +745,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.
          */
-        if (np && (out_of_time || preempt || sleep)) {
+        if (np && (out_of_time || preempted || sleep)) {
                 unlink(entry->scheduled);
                 request_exit_np(entry->scheduled);
         }
@@ -695,10 +761,21 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
 
         /* Link pending task if we became unlinked.
          */
-        // TODO make container only be scheduled on cores with same id
-        if (!entry->linked)
-                link_task_to_cpu(__take_ready(&gsched_domain), entry);
+        // make container only be scheduled on cores with same id
+        if (!entry->linked) {
+                struct task_struct* task = __take_ready(&gsched_domain);
+                cpu_entry_t* target = entry; 
+                if (is_container(task)) {
+                        target = &per_cpu(edfsc_cpu_entries, tsk_rt(task)->edfsc_params.id);
+                }
+                if (target != entry) {
+                        link_task_to_cpu(target->linked, entry);
+                }
+                link_task_to_cpu(task, target);
+                preempt(target);
+
                 BUG_ON(entry->linked && budget_exhausted(entry->linked));
+        }
 
         BUG_ON(entry->linked && budget_exhausted(entry->linked));
 
@@ -900,24 +977,35 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
 
         // Re-release container tasks, or tell them they can if they're tardy
         for (i = 0; i < num_cpus; i++) {
+                // will first iterate through fully provisioned containers, then not fully provisioned ones
                 struct task_struct* t = container_list[i]->container;
                 printk("container id: %d\n", tsk_rt(t)->edfsc_params.id);
                 printk("container budget: %lld\n", budget_remaining(t));
                 // If the last job completed on time, release it now
                 if (budget_exhausted(t)) {
+                        BUG_ON(is_queued(t));
                         prepare_for_next_period(t);
-                        if (is_early_releasing(t) || is_released(t, now)) {
+                        if (is_early_releasing(t) || is_released(t, now))
                                 sched_trace_task_release(t);
+                        if (get_rt_utilization(t) == to_fp(1)) {
+                                cpu_entry_t* entry = &per_cpu(edfsc_cpu_entries, tsk_rt(t)->edfsc_params.id);
+                                remove_cpu_from_global(entry);
+                                entry->linked = t;
+                                tsk_rt(t)->linked_on = entry->cpu;
+                                cancel_idle_enforcement_timer(t);
+                                preempt(entry);
                         }
-                        /* requeue
-                         * But don't requeue a blocking task. */
-                        if (is_current_running()) { //since we don't support blocking, this should always be true
-                                if (tsk_rt(t)->edfsc_params.domain->scheduled) {
-                                        requeue(tsk_rt(t)->edfsc_params.domain->scheduled);
-                                        tsk_rt(t)->edfsc_params.domain->scheduled = NULL;
+                        else {
+                                cpu_entry_t* entry = &per_cpu(edfsc_cpu_entries, tsk_rt(t)->edfsc_params.id);
+                                add_cpu_to_global(entry);
+                                if (is_current_running()) { //since we don't support blocking, this should always be true
+                                        if (tsk_rt(t)->edfsc_params.domain->scheduled) {
+                                                requeue(tsk_rt(t)->edfsc_params.domain->scheduled);
+                                                tsk_rt(t)->edfsc_params.domain->scheduled = NULL;
+                                        }
+                                        requeue(t);
+                                        g_preempt_check();
                                 }
-                                requeue(t);
-                                g_preempt_check();
                         }
                 // Otherwise let it release itself when it completes
                 } else {
@@ -1196,20 +1284,6 @@ static struct sched_plugin edfsc_plugin __cacheline_aligned_in_smp = {
         .get_domain_proc_info   = edfsc_get_domain_proc_info,
 };
 
-//timeout for timer enforcing budget of empty container
-static enum hrtimer_restart on_idle_enforcement_timeout(struct hrtimer *timer)
-{
-        cont_domain_t* domain = container_of(timer, cont_domain_t, idle_enforcement_timer);
-
-        unsigned long flags;
-
-        local_irq_save(flags);
-        domain->timer_armed = 0;
-        litmus_reschedule_local();
-        local_irq_restore(flags);
-
-        return HRTIMER_NORESTART;
-}
 
 static int __init init_edfsc(void)
 {