changes to budget tracking and scheduling

consolidated container budget tracking
properly excluded fully provisioned containers and their cpus from gedf
gschedule no longer returns non-rt tasks

1 files changed, 44 insertions, 50 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 218123d99514..754891b8c12f 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -64,9 +64,9 @@ static rt_domain_t gsched_domain;
 u64 m_util, future_m_util;
 u64 sys_util, future_sys_util;
 
-// FIXME something's fishy here -- is_migrating shouldn't be stronger than is_container right?
 #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)
+//migrating task can temporarily have a container_task when it is being background scheduled
 #define is_migrating(task) ((task) && tsk_rt(task)->edfsc_params.domain == NULL && tsk_rt(task)->domain == &gsched_domain)
 
 #define FP_SHIFT 20
@@ -145,7 +145,7 @@ static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
         /* Note that a and b are inverted: we want the lowest-priority CPU at
          * the top of the heap.
          */
-        return (is_container(b->linked) && get_rt_utilization(b->linked) == to_fp(1)) || edf_higher_prio(b->linked, a->linked);
+        return edf_higher_prio(b->linked, a->linked);
 }
 
 /* caller must hold g_lock */
@@ -340,7 +340,6 @@ static void g_preempt_check(void)
                 edf_preemption_needed(&gsched_domain, last->linked);
                 last = lowest_prio_cpu()) {
                 target = last;
-                BUG_ON(is_container(last->linked) && get_rt_utilization(last->linked) == to_fp(1));
 
                 /* preemption necessary */
                 task = __take_ready(&gsched_domain);
@@ -439,8 +438,6 @@ 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 */
@@ -478,17 +475,21 @@ static noinline void g_job_completion(struct task_struct* t, int forced)
                 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);
+                cpu_entry_t* entry = &per_cpu(edfsc_cpu_entries, tsk_rt(t)->edfsc_params.id);
                 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);
+                        if (bheap_node_in_heap(entry->hn))
+                                remove_cpu_from_global(entry);
                         entry->linked = t;
                         tsk_rt(t)->linked_on = entry->cpu;
-                        cancel_idle_enforcement_timer(t);
+                        if (is_queued(t))
+                                remove(&gsched_domain, t);
+                        manage_idle_enforcement_timer(t);
                         preempt(entry);
                 }
                 else {
+                        update_cpu_position(entry);
                         if (is_current_running()) {
                                 if (tsk_rt(t)->edfsc_params.domain->scheduled) {
                                         requeue(tsk_rt(t)->edfsc_params.domain->scheduled);
@@ -518,6 +519,7 @@ static void c_job_completion(struct task_struct* t, int forced)
                 }
         } else {
                 prepare_for_next_period(t);
+                requeue(t);
         }
 }
 
@@ -527,13 +529,18 @@ static void g_finish_switch(struct task_struct *prev)
         cpu_entry_t* entry = this_cpu_ptr(&edfsc_cpu_entries);
         BUG_ON(is_realtime(current) && tsk_rt(current)->domain == NULL);
 
-        if (!is_container(entry->linked)) {
-                entry->scheduled = is_realtime(current) ? current : NULL;
-                if (entry->scheduled)
-                        entry->scheduled = (is_fixed(current)) ? tsk_rt(current)->edfsc_params.container_task : current;
+        entry->scheduled = is_realtime(current) ? current : NULL;
+        if (entry->scheduled) {
+                // when a task is being scheduled under a container, container_task exists
+                struct task_struct* t = tsk_rt(current)->edfsc_params.container_task;
+                entry->scheduled = (t) ? t : current;
         }
-        else
+        // occurs when current is non-rt, and linked is a container
+        // this happens when an empty container "task" is supposed to be current
+        // but because it's not a real task, a non-rt task is current instead
+        else if (is_container(entry->linked)) {
                 entry->scheduled = entry->linked;
+        }
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE_TASK(prev, "switched away from\n");
 #endif
@@ -549,9 +556,8 @@ static int fifo_prio(struct bheap_node* _a, struct bheap_node* _b)
  * Called with g_lock already held
  * @param cedf Pointer to tsk_rt(container)->edfsc_params->domain
  * @param prev Previous task running on this processor before schedule was called
- * @returns `cedf->container` if no fixed task is next
  */
-static struct task_struct* edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
+static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
 {
         rt_domain_t *edf = &cedf->domain;
 
@@ -577,7 +583,7 @@ static struct task_struct* edfsc_cschedule(cont_domain_t* cedf, struct task_stru
                                  && budget_exhausted(cedf->scheduled);
         np              = exists && is_np(cedf->scheduled);
         sleep           = exists && is_completed(cedf->scheduled);
-        preempt  = !is_realtime(prev) || is_migrating(prev) || edf_preemption_needed(edf, prev);
+        preempt  = (is_migrating(prev) && __peek_ready(edf)) || edf_preemption_needed(edf, prev);
 
         /* If we need to preempt do so.
          * The following checks set resched to 1 in case of special
@@ -620,9 +626,6 @@ static struct task_struct* edfsc_cschedule(cont_domain_t* cedf, struct task_stru
                  * release queue (if it completed). requeue() picks
                  * the appropriate queue.
                  */
-                if (cedf->scheduled && !blocks)
-                        requeue(cedf->scheduled);
-
                 next = __take_ready(edf);
         } else
                 /* Only override Linux scheduler if we have a real-time task
@@ -650,28 +653,15 @@ static struct task_struct* edfsc_cschedule(cont_domain_t* cedf, struct task_stru
                 }
         }
 
-        //XXX possible error in logic here
-        // FIXME definite error: next can be NULL (it definitely is when there are
-        // no real tasks in the system).
-        if (next) {
-                cedf->changed_budget = (budget_remaining(next) > budget_remaining(cedf->container))
-                        ? budget_remaining(cedf->container) - budget_remaining(next) : 0;
-                cedf->scheduled_last_exec_time = get_exec_time(next);
-                tsk_rt(next)->job_params.exec_time -= cedf->changed_budget;
-        }
-
         cedf->scheduled = next;
-
-        return (next) ? next : cedf->container;
 }
 
-
 //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, preempted, np, exists, blocks, is_cont;
-        struct task_struct* next = NULL;
+        struct task_struct* next;
         unsigned long flags;
 
         raw_spin_lock_irqsave(&g_lock, flags);
@@ -767,7 +757,7 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         // 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; 
+                cpu_entry_t* target = entry;
                 if (is_container(task)) {
                         target = &per_cpu(edfsc_cpu_entries, tsk_rt(task)->edfsc_params.id);
                 }
@@ -781,17 +771,17 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         }
 
         BUG_ON(entry->linked && budget_exhausted(entry->linked));
+        BUG_ON(!bheap_node_in_heap(entry->hn) && tsk_rt(entry->linked)->edfsc_params.id != entry->cpu);
 
         /* The final scheduling decision. Do we need to switch for some reason?
          * If linked is different from scheduled, then select linked as next.
          */
+        next = NULL;
         if ((!np || blocks) && entry->linked != entry->scheduled) {
                 /* Schedule a linked job? */
                 if (entry->linked) {
                         entry->linked->rt_param.scheduled_on = entry->cpu;
                         next = entry->linked;
-                        if (is_container(next))
-                                next = edfsc_cschedule(tsk_rt(next)->edfsc_params.domain, prev);
                         TRACE_TASK(next, "scheduled_on = P%d\n", smp_processor_id());
                 }
                 if (entry->scheduled) {
@@ -800,11 +790,13 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                         TRACE_TASK(entry->scheduled, "scheduled_on = NO_CPU\n");
                 }
         } else {
-                BUG_ON(entry->linked != entry->scheduled);
-                if (is_container(entry->scheduled))
-                        next = edfsc_cschedule(tsk_rt(entry->scheduled)->edfsc_params.domain, prev);
+                if (exists)
+                        next = prev;
         }
 
+        if (is_container(next))
+                edfsc_cschedule(tsk_rt(next)->edfsc_params.domain, prev);
+
         sched_state_task_picked();
 
         raw_spin_unlock_irqrestore(&g_lock, flags);
@@ -818,15 +810,11 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                 TRACE("becomes idle at %llu.\n", litmus_clock());
 #endif
 
-        // If next is a container, then edfsc_cschedule() found nothing to schedule
+        // 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)) {
                 manage_idle_enforcement_timer(next);
-                return NULL;
-        }
-        // XXX: Maybe this should be entry->linked
-        else if (next == prev && is_container(entry->scheduled)) {
-                manage_idle_enforcement_timer(entry->scheduled);
-                return next;
+                return tsk_rt(next)->edfsc_params.domain->scheduled;
         }
         else
                 return next;
@@ -857,8 +845,10 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
 
         for (i = 0; i < num_cpus; i++) {
                 t = container_list[i]->container;
-                if (tsk_rt(t)->linked_on != NO_CPU && container_list[i]->scheduled == NULL)
+                if (container_list[i]->timer_armed)
                         tsk_rt(t)->job_params.exec_time += now - container_list[i]->scheduled_last_exec_time;
+                else
+                        tsk_rt(t)->job_params.exec_time = get_exec_cost(t);
         }
 
         t = NULL;
@@ -987,9 +977,12 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                                 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);
+                                if (bheap_node_in_heap(entry->hn))
+                                        remove_cpu_from_global(entry);
                                 entry->linked = t;
                                 tsk_rt(t)->linked_on = entry->cpu;
+                                if (is_queued(t))
+                                        remove(&gsched_domain, t);
                                 cancel_idle_enforcement_timer(t);
                                 preempt(entry);
                         }
@@ -1008,8 +1001,7 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                 // Otherwise let it release itself when it completes
                 } else {
                         tsk_rt(t)->edfsc_params.can_release = 1;
-                        if (tsk_rt(t)->edfsc_params.domain->scheduled == NULL)
-                                manage_idle_enforcement_timer(t);
+                        manage_idle_enforcement_timer(t);
                 }
         }
 
@@ -1328,6 +1320,8 @@ static int __init init_edfsc(void)
                 tsk_rt(&container_tasks[i])->edfsc_params.domain = &container_domains[i];
                 tsk_rt(&container_tasks[i])->edfsc_params.can_release = 0;
 
+                tsk_rt(&container_tasks[i])->sporadic_release = 0;
+
                 tsk_rt(&container_tasks[i])->heap_node = kmalloc(sizeof(struct bheap_node), GFP_KERNEL);
                 bheap_node_init(&tsk_rt(&container_tasks[i])->heap_node, &container_tasks[i]);
                 requeue(&container_tasks[i]);