WIP with my local changes

contains changes regarding link_task_to_cpu and how budget enforcement
works

1 files changed, 74 insertions, 53 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 927f35ebc68f..74737eddd4af 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -114,6 +114,7 @@ static noinline void requeue(struct task_struct* task)
         /* sanity check before insertion */
         BUG_ON(is_queued(task));
         BUG_ON(!is_realtime(task));
+        BUG_ON(budget_enforced(task) && budget_exhausted(task));
 
         if (is_early_releasing(task) || is_released(task, litmus_clock())) {
                 __add_ready((rt_domain_t *) tsk_rt(task)->domain, task);
@@ -260,6 +261,7 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
 
         BUG_ON(linked && !is_realtime(linked));
         BUG_ON(is_fixed(linked));
+        BUG_ON(is_container(linked) && tsk_rt(linked)->edfsc_params.id != entry->cpu);
 
         /* Currently linked task is set to be unlinked. */
         if (entry->linked) {
@@ -269,9 +271,9 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
         /* Link new task to CPU. */
         if (linked) {
                 /* handle task is already scheduled somewhere! */
-                on_cpu = linked->rt_param.scheduled_on;
-                if (on_cpu != NO_CPU) {
-                        sched = &per_cpu(edfsc_cpu_entries, on_cpu);
+                //on_cpu = linked->rt_param.scheduled_on;
+                //if (on_cpu != NO_CPU) {
+                        //sched = &per_cpu(edfsc_cpu_entries, on_cpu);
                         /* this should only happen if not linked already */
                         // Except in the case of swapping linked tasks between cpus
                         //BUG_ON(sched->linked == linked);
@@ -281,21 +283,23 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                          * we just link ourselves to the CPU and depend on
                          * the caller to get things right.
                          */
-                        if (entry != sched) {
-                                TRACE_TASK(linked,
-                                           "already scheduled on %d, updating link.\n",
-                                           sched->cpu);
-                                tmp = sched->linked;
-                                linked->rt_param.linked_on = sched->cpu;
-                                sched->linked = linked;
-                                update_cpu_position(sched);
-                                linked = tmp;
-                        }
-                }
+                        //if (entry != sched) {
+                        //      BUG_ON(true);
+                        //      TRACE_TASK(linked,
+                        //                 "already scheduled on %d, updating link.\n",
+                        //                 sched->cpu);
+                        //      tmp = sched->linked;
+                        //      linked->rt_param.linked_on = sched->cpu;
+                        //      sched->linked = linked;
+                        //      update_cpu_position(sched);
+                        //      linked = tmp;
+                        //}
+                //}
                 if (linked) /* might be NULL due to swap */
                         linked->rt_param.linked_on = entry->cpu;
         }
         entry->linked = linked;
+        BUG_ON(is_container(linked) && tsk_rt(linked)->edfsc_params.id != entry->cpu);
 #ifdef WANT_ALL_SCHED_EVENTS
         if (linked)
                 TRACE_TASK(linked, "linked to %d.\n", entry->cpu);
@@ -374,9 +378,11 @@ static void g_preempt_check(void)
                 if (target != last) {
                         TRACE("check_for_preemptions: swapping tasks linked on %d and %d\n",
                                         last->cpu, target->cpu);
+                        BUG_ON(is_container(target->linked) && last->cpu != tsk_rt(target->linked)->edfsc_params.id);
                         link_task_to_cpu(target->linked, last);
                         preempt(last);
                 }
+                BUG_ON(is_container(task) && target->cpu != tsk_rt(task)->edfsc_params.id);
                 link_task_to_cpu(task, target);
                 preempt(target);
         }
@@ -466,6 +472,7 @@ static void c_release(struct task_struct *t) {
          */
         if (get_rt_utilization(t) == to_fp(1)) {
                 cpu_entry_t* entry = &per_cpu(edfsc_cpu_entries, tsk_rt(t)->edfsc_params.id);
+                BUG_ON(entry->linked);
                 // Make this cpu unavailable to the global scheduler
                 if (bheap_node_in_heap(entry->hn))
                         remove_cpu_from_global(entry);
@@ -487,10 +494,10 @@ static void c_release(struct task_struct *t) {
                 if (!bheap_node_in_heap(entry->hn))
                         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;
-                        }
+                        //if (tsk_rt(t)->edfsc_params.domain->scheduled) {
+                        //      requeue(tsk_rt(t)->edfsc_params.domain->scheduled);
+                        //      tsk_rt(t)->edfsc_params.domain->scheduled = NULL;
+                        //}
                         // Let g_preempt_check() decide what to run, don't impose
                         unlink(t);
                         // Request to be scheduled globally again
@@ -499,6 +506,8 @@ static void c_release(struct task_struct *t) {
                         // Re-run our EDF scheduling to adjust for the added core
                         g_preempt_check();
                 }
+                else
+                        BUG_ON(true);
         }
 }
 
@@ -535,6 +544,8 @@ static noinline void g_job_completion(struct task_struct* t, int forced)
                         requeue(t);
                         g_preempt_check();
                 }
+                else
+                        BUG_ON(true);
         // 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;
@@ -542,6 +553,10 @@ static noinline void g_job_completion(struct task_struct* t, int forced)
                 if (get_rt_utilization(t) == to_fp(1))
                         manage_idle_enforcement_timer(t);
         }
+        else {
+                BUG_ON(is_queued(t));
+        }
+        BUG_ON(is_migrating(t) && budget_enforced(t) && budget_exhausted(t));
 }
 
 // fixed task job_completion, called from edfsc_cschedule
@@ -576,10 +591,12 @@ static void g_finish_switch(struct task_struct *prev)
                 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;
-        }
+        BUG_ON(is_migrating(entry->linked) && !entry->scheduled);
+        BUG_ON(is_realtime(current) && !entry->scheduled);
+        //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
@@ -596,7 +613,7 @@ static int fifo_prio(struct bheap_node* _a, struct bheap_node* _b)
  * @param cedf Pointer to tsk_rt(container)->edfsc_params->domain
  * @param prev Previous task running on this processor before schedule was called
  */
-static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
+static struct task_struct* edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
 {
         rt_domain_t *edf = &cedf->domain;
 
@@ -611,7 +628,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 */
@@ -621,7 +638,7 @@ 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)) || edf_preemption_needed(edf, cedf->scheduled);
 
         /* If we need to preempt do so.
          * The following checks set resched to 1 in case of special
@@ -668,13 +685,12 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
                  */
                 next = __take_ready(edf);
         } else if (exists) {
-                BUG_ON(!is_realtime(prev));
                 /* Only override Linux scheduler if we have a real-time task
                  * scheduled that needs to continue.
                  */
-                next = prev;
+                next = cedf->scheduled;
         }
-
+        /*
         if (next) {
                 TRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
         } else {
@@ -689,14 +705,17 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
                 if (next) {
                         TRACE("stealing slack at %llu\n", litmus_clock());
                 } else {
+        tsk_rt(t)->task_params.budget_policy = PRECISE_ENFORCEMENT;
                         TRACE("cpu become idle at %llu\n", litmus_clock());
                 }
                 while (bheap_peek(fifo_prio, &temp)) {
                         requeue(bheap_take(fifo_prio, &temp)->value);
                 }
         }
-
+        */
         cedf->scheduled = next;
+        BUG_ON(next && budget_enforced(next) && budget_exhausted(next));
+        return next;
 }
 
 //assuming prev is previous task running on the processor before calling schedule
@@ -720,7 +739,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         // jobs of fixed tasks.
         BUG_ON(entry->scheduled && !is_container(entry->scheduled) && !is_realtime(prev));
         // Bug if we didn't think anything was scheduled, but a realtime task was running on our CPU
-        BUG_ON(is_realtime(prev) && !entry->scheduled && entry->cpu == tsk_rt(prev)->scheduled_on);
+        //BUG_ON(is_realtime(prev) && !entry->scheduled && entry->cpu == tsk_rt(prev)->scheduled_on);
 
         if (is_container(entry->scheduled)) {
                 lt_t now = litmus_clock();
@@ -758,8 +777,9 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         /* If a task blocks we have no choice but to reschedule.
          * Note: containers never block
          */
-        if (blocks)
+        if (blocks) {
                 unlink(entry->scheduled);
+        }
 
         /* Request a sys_exit_np() call if we would like to preempt but cannot.
          * We need to make sure to update the link structure anyway in case
@@ -778,17 +798,16 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
          */
         if (!np && (out_of_time || sleep)) {
                 // This is not a global job completion if we're in a fully provisioned container
-                if (bheap_node_in_heap(entry->hn))
+                if (is_migrating(entry->scheduled) || bheap_node_in_heap(entry->hn))
                         g_job_completion(entry->scheduled, !sleep);
                 else
                         unlink(entry->scheduled);
-                BUG_ON(entry->linked && budget_exhausted(entry->linked));
+                BUG_ON(entry->linked && budget_enforced(entry->linked) && budget_exhausted(entry->linked));
         }
 
         // Determine what to run next (set entry->linked)
         if (!entry->linked) {
                 struct task_struct* task = __take_ready(&gsched_domain);
-                //printk("next task: %d\n", task);
                 // Make sure that containers are only scheduled on cores with same id
                 if (is_container(task) && entry->cpu != tsk_rt(task)->edfsc_params.id) {
                         // Get cpu_entry for task's core assignment
@@ -799,15 +818,16 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                         // I guess this is one way to avoid overwriting target->linked?
                         // Peter: This was in your original implementation, is this right? -Joshua
                         link_task_to_cpu(target->linked, entry);
+                        BUG_ON(is_container(target->linked) && tsk_rt(target->linked)->edfsc_params.id != entry->cpu);
                         // Setup the container to run next on the remote core
                         link_task_to_cpu(task, target);
-                        BUG_ON(budget_exhausted(task));
+                        BUG_ON(budget_enforced(task) && budget_exhausted(task));
                         // Alert the remote core that it now needs to reschedule
                         preempt(target);
                 } else {
                         // We'll now schedule the ready task here
                         link_task_to_cpu(task, entry);
-                        BUG_ON(task && budget_exhausted(task));
+                        BUG_ON(task && budget_enforced(task) && budget_exhausted(task));
                         // Give up on this scheduling cycle, as we need to re-check the
                         // conditions earlier on in edfsc_gschedule()
                         //if (task)
@@ -819,7 +839,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                 //XXX modify this into a while loop?
                 //goto out;
         }
-        BUG_ON(entry->linked && budget_exhausted(entry->linked));
+        BUG_ON(entry->linked && budget_enforced(entry->linked) && budget_exhausted(entry->linked));
         BUG_ON(!bheap_node_in_heap(entry->hn) && entry->linked && tsk_rt(entry->linked)->edfsc_params.id != entry->cpu);
         BUG_ON(is_container(entry->linked) && tsk_rt(entry->linked)->edfsc_params.id != entry->cpu);
 
@@ -839,28 +859,30 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                         TRACE_TASK(entry->scheduled, "scheduled_on = NO_CPU\n");
                 }
         } else if (entry->scheduled) {
-                // If we've been running a container, make sure that it has nothing new to schedule
-                if (is_container(entry->scheduled))
-                        next = entry->scheduled;
-                // Otherwise we can keep running any tasks we previously scheduled
-                else if (is_realtime(prev))
+                if (is_realtime(prev))
                         next = prev;
         }
 
-        if (is_container(next))
-                edfsc_cschedule(tsk_rt(next)->edfsc_params.domain, prev);
+        if (is_container(next)) {
+                struct task_struct* temp = next;
+                next = edfsc_cschedule(tsk_rt(next)->edfsc_params.domain, prev);
+                if (bheap_node_in_heap(entry->hn))
+                        manage_idle_enforcement_timer(temp);
+        }
 
 //out:
 //      sched_state_task_picked();
 
         // if no fixed tasks to be scheduled by the container, then container->scheduled
         // should be the previous non-rt task if any
-        if (is_container(next)) {
-                if (bheap_node_in_heap(entry->hn))
-                        manage_idle_enforcement_timer(next);
-                next = tsk_rt(next)->edfsc_params.domain->scheduled;
-        }
-
+        //if (is_container(next)) {
+        //      if (bheap_node_in_heap(entry->hn))
+        //              manage_idle_enforcement_timer(next);
+        //      next = tsk_rt(next)->edfsc_params.domain->scheduled;
+        //}
+
+        BUG_ON(is_migrating(entry->linked) && next != entry->linked);
+        BUG_ON(next && budget_enforced(next) && budget_exhausted(next));
         raw_spin_unlock_irqrestore(&g_lock, flags);
 
 #ifdef WANT_ALL_SCHED_EVENTS
@@ -922,7 +944,6 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                                 //printk("container: %d\n", container_domains[i].f_util);
                                 if (leftover >= get_rt_utilization(t)) {
                                         container = &(container_domains[i]);
-                                        printk("container id: %d\n", i);
                                         break;
                                 }
                         }
@@ -1063,7 +1084,7 @@ static enum hrtimer_restart task_deadline_callback(struct hrtimer* timer) {
         // 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
-                if (!is_released(t, litmus_clock()) || budget_exhausted(t))
+                if (!is_released(t, litmus_clock()) || (budget_exhausted(t) && budget_enforced(t)) || is_completed(t))
                         migrate_task(t);
         } else {
                 // A move to NULL means deletion
@@ -1406,7 +1427,7 @@ static int __init init_edfsc(void)
                 entry->linked = NULL;
                 entry->hn = &edfsc_cpu_heap_node[i];
                 bheap_node_init(&entry->hn, entry);
-                entry->scheduled = NULL;
+                bheap_insert(cpu_lower_prio, &edfsc_cpu_heap, entry->hn);
         }
 
         return register_sched_plugin(&edfsc_plugin);