Non-logic-changing cleanup

Changes are:
- Remove broken, commented out code
- Remove printk debugging (known to be unreliable)
- Name containers with IDs over 9 correctly
- Clarify existing and add new TRACE logging calls
- Fix inconsistent coding style

1 files changed, 14 insertions, 44 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 0a7d8131ab54..a91951480f33 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -305,24 +305,6 @@ static void g_preempt_check(void)
         struct task_struct *task;
         cpu_entry_t *last, *target;
 
-#ifdef CONFIG_PREFER_LOCAL_LINKING
-
-        /* Before linking to other CPUs, check first whether the local CPU is
-         * idle. */
-        //TODO come back this this later. This is causing a problem with g_preempt
-        /*
-        cpu_entry_t *local = this_cpu_ptr(&edfsc_cpu_entries);
-        task  = __peek_ready(&gsched_domain);
-
-        if (task && !local->linked) {
-                task = __take_ready(&gsched_domain);
-                TRACE_TASK(task, "linking to local CPU %d to avoid IPI\n", local->cpu);
-                link_task_to_cpu(task, local);
-                preempt(local);
-        }
-        */
-#endif
-
         // Loop through CPUs in priority order, checking if anything needs preemption
         for (last = lowest_prio_cpu();
                 edf_preemption_needed(&gsched_domain, last->linked);
@@ -449,8 +431,7 @@ static void c_release(struct task_struct *t) {
                 tsk_rt(t)->edfsc_params.domain->scheduled_last_exec_time = litmus_clock();
                 // Run schedule again to make sure that we're run
                 preempt(entry);
-        }
-        else {
+        } else {
                 // Make our cpu available again
                 if (!bheap_node_in_heap(entry->hn))
                         add_cpu_to_global(entry);
@@ -575,7 +556,7 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
 {
         rt_domain_t *edf = &cedf->domain;
 
-        struct task_struct*     next;
+        struct task_struct* next;
         struct bheap temp;
         int             out_of_time, sleep, preempt,
                                 np, exists, blocks, resched;
@@ -590,13 +571,13 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
         BUG_ON(cedf->scheduled && !is_realtime(cedf->scheduled));
 
         /* (0) Determine state */
-        exists    = cedf->scheduled != NULL;
-        blocks    = exists && !is_current_running();
-        out_of_time = exists && budget_enforced(cedf->scheduled)
-                                 && budget_exhausted(cedf->scheduled);
-        np              = exists && is_np(cedf->scheduled);
+        exists          = cedf->scheduled != NULL;
+        blocks          = exists && !is_current_running();
+        out_of_time     = exists && budget_enforced(cedf->scheduled)
+                                         && 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(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
@@ -622,9 +603,8 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
         if (!np && (out_of_time || sleep)) {
                 if (is_fixed(cedf->scheduled))
                         c_job_completion(cedf->scheduled, !sleep);
-                else {
+                else
                         g_job_completion(cedf->scheduled, !sleep);
-                }
                 resched = 1;
         }
 
@@ -660,9 +640,9 @@ static void edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)
                         BUG_ON(next && is_queued(next));
                 }
                 if (next) {
-                        TRACE("stealing slack at %llu\n", litmus_clock());
+                        TRACE_TASK(next, "background scheduling at %llu\n", litmus_clock());
                 } else {
-                        TRACE("cpu become idle at %llu\n", litmus_clock());
+                        TRACE("container becomes idle at %llu\n", litmus_clock());
                 }
                 while (bheap_peek(fifo_prio, &temp)) {
                         requeue(bheap_take(fifo_prio, &temp)->value);
@@ -712,9 +692,6 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         sleep           = exists && !is_cont && is_completed(entry->scheduled);
         preempted        = entry->scheduled != entry->linked;
 
-#ifdef WANT_ALL_SCHED_EVENTS
-        TRACE_TASK(prev, "invoked gsnedf_schedule.\n");
-#endif
 
         if (exists)
                 TRACE_TASK(prev,
@@ -854,8 +831,6 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
 
         raw_spin_lock_irqsave(&g_lock, flags);
 
-        printk("\ncontainer_boundary\n");
-
         now = litmus_clock();
 
         // Update budget tracking for containers
@@ -874,13 +849,10 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                 u_extra = to_fp(num_cpus) - sys_util;
                 container = NULL;
                 t = task_of_list_node(it);
-                printk("sys_util: %d\n", sys_util);
-                printk("task util: %d\n", get_rt_utilization(t));
                 list_del_init(it);
                 if (u_extra >= get_rt_utilization(t)) {
                         for (i = 0; i < num_cpus; i++) {
                                 u64 leftover = to_fp(1) - container_domains[i].f_util;
-                                printk("container: %d\n", container_domains[i].f_util);
                                 if (leftover >= get_rt_utilization(t)) {
                                         container = &(container_domains[i]);
                                         break;
@@ -993,8 +965,6 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
         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));
@@ -1006,7 +976,6 @@ static enum hrtimer_restart container_boundary(struct hrtimer *timer)
                 }
         }
 
-        printk("/container_boundary\n\n");
         raw_spin_unlock_irqrestore(&g_lock, flags);
 
         hrtimer_add_expires_ns(timer, LITMUS_QUANTUM_LENGTH_NS);
@@ -1106,6 +1075,7 @@ static void edfsc_task_exit(struct task_struct* t)
 
         BUG_ON(is_container(t));
         raw_spin_lock_irqsave(&g_lock, flags);
+        TRACE_TASK(t, "called edfsc_task_exit\n");
 
         // Remove this task from all members of its scheduling domain
         unlink(t);
@@ -1339,8 +1309,8 @@ static int __init init_edfsc(void)
                 container_domains[i].idle_enforcement_timer.function = on_idle_enforcement_timeout;
 
 
-                tsk_rt(&container_tasks[i])->scheduled_on = NO_CPU;
-                container_tasks[i].comm[0] = i + 48; // Name the task its container ID mapped to ASCII
+                // Name the task its container ID mapped to ASCII
+                snprintf(container_tasks[i].comm, TASK_COMM_LEN, "%d", i);
                 tsk_rt(&container_tasks[i])->task_params.exec_cost = LITMUS_QUANTUM_LENGTH_NS / 2;
                 tsk_rt(&container_tasks[i])->task_params.period =
                         LITMUS_QUANTUM_LENGTH_NS;