Added edfsc parameters in rt_param.h

updated references to parameters in edfsc plugin

1 files changed, 79 insertions, 41 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 3abe2cf93664..1f6e82a9b954 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -125,14 +125,8 @@ static void update_cpu_position(cpu_entry_t *entry)
         bheap_insert(cpu_lower_prio, &edfsc_cpu_heap, entry->hn);

 }

 

-/////////////////////////////////////////////////////////////////////////////////////

-/*

- *

- * GLOBAL SCHEDULING

- *

- */

-

-/* link_task_to_cpu - Update the link of a CPU.

+/* link_task_to_cpu - Links a migrating task or container to a CPU

+ *                                        Update the link of a CPU.

  *                    Handles the case where the to-be-linked task is already

  *                    scheduled on a different CPU.

  */

@@ -144,6 +138,7 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
         int on_cpu;

 

         BUG_ON(linked && !is_realtime(linked));

+        BUG_ON(is_fixed(linked));

 

         /* Currently linked task is set to be unlinked. */

         if (entry->linked) {

@@ -188,6 +183,30 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
         update_cpu_position(entry);

 }

 

+/* unlink - Make sure a task is not linked any longer to an entry

+ *          where it was linked before. Must hold gsnedf_lock.

+ */

+static noinline void unlink(struct task_struct* t)

+{

+        cpu_entry_t *entry;

+

+        if (t->rt_param.linked_on != NO_CPU) {

+                /* unlink */

+                entry = &per_cpu(edfsc_cpu_entries, t->rt_param.linked_on);

+                t->rt_param.linked_on = NO_CPU;

+                link_task_to_cpu(NULL, entry);

+        } else if (is_queued(t)) {

+                /* This is an interesting situation: t is scheduled,

+                 * but was just recently unlinked.  It cannot be

+                 * linked anywhere else (because then it would have

+                 * been relinked to this CPU), thus it must be in some

+                 * queue. We must remove it from the list in this

+                 * case.

+                 */

+                remove(&gsched_domain, t);

+        }

+}

+

 static void g_preempt_check(void)

 {

         struct task_struct *task;

@@ -234,7 +253,7 @@ static int c_preempt_check(container_domain_t* container)
                 return 0;

 }

 

-//migrating or container task job_completion

+//migrating or container task job_completion, called from edfsc_gschedule

 static noinline void g_job_completion(struct task_struct* t, int forced)

 {

         BUG_ON(!t);

@@ -247,34 +266,46 @@ static noinline void g_job_completion(struct task_struct* t, int forced)
         tsk_rt(t)->completed = 0;

         

         //is at later of job completion and job deadline

-        if (is_migrating(t) && t->rt_param.job_params.lateness > 0 && t->edfsc_params.will_remove) {

+        if (is_migrating(t) && t->rt_param.job_params.lateness > 0 && tsk_rt(t)->edfsc_params.will_remove) {

                 //update task utilizations

         }

         

-        /* prepare for next period */

-        prepare_for_next_period(t);

-        if (is_early_releasing(t) || is_released(t, litmus_clock()))

-                sched_trace_task_release(t);

-        /* unlink */

-        unlink(t);

-        /* requeue

-         * But don't requeue a blocking task. */

-        if (is_current_running())

-                requeue(t, gsched_domain);

-                g_preempt_check();

+        if (is_migrating(t) && tsk_rt(t)->edfsc_params.will_remove) {

+                if (t->rt_param.job_params.lateness > 0) {

+                        //remove the task now

+                }

+        }

+        else {          

+                /* prepare for next period */

+                prepare_for_next_period(t);

+                if (is_early_releasing(t) || is_released(t, litmus_clock()))

+                        sched_trace_task_release(t);

+                /* unlink */

+                unlink(t);

+                /* requeue

+                 * But don't requeue a blocking task. */

+                if (is_current_running()) {

+                        requeue(t, gsched_domain);

+                        g_preempt_check();

+                }

+        }

 }

 

-//fixed task job_completion

+//fixed task job_completion, called from edfsc_cschedule

 static void c_job_completion(struct task_struct* t, int forced)

 {

         sched_trace_task_completion(t, forced);

         TRACE_TASK(t, "job_completion(forced=%d).\n", forced);

 

         tsk_rt(t)->completed = 0;

-        prepare_for_next_period(t);

         

-        if (t->rt_param.job_params.lateness > 0 && t->edfsc_params.will_remove) {

-                //update task utilizations

+        if (tsk_rt(t)->edfsc_params.will_remove) {

+                if (t->rt_param.job_params.lateness > 0) {

+                        //remove the task now

+                }

+        }

+        else {

+                prepare_for_next_period(t);

         }

 }

 

@@ -292,10 +323,10 @@ static void g_finish_switch(struct task_struct *prev)
 

 //takes in the container_domain pointer in container task_struct

 //assuming prev is previous task running on the processor before calling schedule

-static struct task_struct* edfsc_cschedule(rt_domain_t* edf, struct task_struct * prev)

+static struct task_struct* edfsc_cschedule(cont_domain_t* cedf, struct task_struct * prev)

 {

-        cont_domain_t*          cedf = container_of(edf, cont_domain_t, domain);

-

+        rt_domain_t* edf = cedf.domain;

+        

         struct task_struct*     next;

 

         int             out_of_time, sleep, preempt,

@@ -358,7 +389,7 @@ static struct task_struct* edfsc_cschedule(rt_domain_t* edf, struct task_struct
                  * the appropriate queue.

                  */

                 if (cedf->scheduled && !blocks)

-                        requeue(pedf->scheduled, edf);

+                        requeue(cedf->scheduled, edf);

                 next = __take_ready(edf);

         } else

                 /* Only override Linux scheduler if we have a real-time task

@@ -394,10 +425,10 @@ static struct task_struct* edfsc_gschedule(struct task_struct * prev)
         BUG_ON(entry->scheduled && !is_realtime(prev));

         BUG_ON(is_realtime(prev) && !entry->scheduled);

         

-        if (prev && prev->container_task) { //update container budget if fixed task

-                cdomain = prev->container_task->container_domain;

+        if (prev && is_fixed(prev)) { //update container budget if fixed task

+                cont_domain_t* cdomain = tsk_rt(prev->container_task)->edfsc_params.container_domain;

                 prev->job_params.exec_time -= cdomain->changed_budget;

-                prev->container_task->job_params.exec_time += 

+                tsk_rt(prev->edfsc_params)->container_task->job_params.exec_time += 

                         prev->job_params.exec_time - cdomain->scheduled_last_exec_time;

         }

         

@@ -423,7 +454,7 @@ static struct task_struct* edfsc_gschedule(struct task_struct * prev)
                            prev->state, signal_pending(prev), is_cont);

                            

         if (is_cont && !sleep && !preempt && !out_of_time)

-                return edfsc_cschedule(entry->scheduled->container_domain, prev);

+                return edfsc_cschedule(tsk_rt(entry->scheduled)->edfsc_params.container_domain, prev);

                            

         if (entry->linked && preempt)

                 TRACE_TASK(prev, "will be preempted by %s/%d\n",

@@ -452,7 +483,7 @@ static struct task_struct* edfsc_gschedule(struct task_struct * prev)
          * for blocked jobs).

          */

         if (!np && (out_of_time || sleep))

-                curr_job_completion(entry->scheduled, !sleep);

+                g_job_completion(entry->scheduled, !sleep);

 

         /* Link pending task if we became unlinked.

          */

@@ -505,11 +536,11 @@ static void edfsc_task_new(struct task_struct* t, int on_rq, int is_scheduled) {
         

         raw_spin_lock_irqsave(&g_lock, flags);

         

-        t->edfsc_params.will_remove = 0;

-        t->rt_param.sporadic_release = 0;

-        hrtimer_init(&(t->edfsc_params.deadline_timer), CLOCK_MONOTONIC, HRTIMER_MODE_ABS);

+        tsk_rt(t)->edfsc_params.will_remove = 0;

+        tsk_rt(t).sporadic_release = 0;

+        hrtimer_init(&(tsk_rt(t)->edfsc_params.deadline_timer), CLOCK_MONOTONIC, HRTIMER_MODE_ABS);

         

-        list_add_tail(t->edfsc_params.qnode, pending_adds);

+        list_add_tail(tsk_rt(t)->edfsc_params.qnode, pending_adds);

         

         if (is_scheduled) {

                 entry = &per_cpu(gsnedf_cpu_entries, task_cpu(t));

@@ -523,19 +554,26 @@ static void edfsc_task_new(struct task_struct* t, int on_rq, int is_scheduled) {
         raw_spin_unlock_irqrestore(&g_lock, flags);

 }

 

+//finds the task_struct of the hrtimer set by task_exit

+static struct task_struct* task_of_timer(struct hrtimer* timer) {

+        edfsc_params* a = container_of(timer, edfsc_params, deadline_timer);

+        rt_param* b = container_of(a, rt_params, edfsc_params);

+        return container_of(b, struct task_struct, rt_param);

+}

+

 static void edfsc_task_exit(struct task_struct* t) {

         

         unsigned long flags;

         

         raw_spin_lock_irqsave(&g_lock, flags);

         

-        t->edfsc_params.will_remove = 1;

+        tsk_rt(t)->edfsc_params.will_remove = 1;

         

         if (is_released(t, litmus_clock())) {

-                hrtimer_start(&(t->edfsc_params.deadline_timer), 

+                hrtimer_start(&(tsk_rt(t)->edfsc_params.deadline_timer), 

                                                 ns_to_ktime(t->rt_param.job_params.deadline),

                         HRTIMER_MODE_ABS_PINNED);

-                t->edfsc_params.deadline_timer.function = asdf; //TODO: update system utilizations

+                tsk_rt(t)->edfsc_params.deadline_timer.function = asdf; //TODO: hook up task removal function

         }

         else {

                 //update system utilizations