End of day commit 2/26/2020

changed edfsc_cschedule found no fixed task to be next, it will now
return the container instead of null

To explain the other changes, first I must explain the problem.
When a container has no fixed tasks, but still has budget, there is
nothing in litmus that enforces its budget or updates its exec_time in
job_params.

This means we will have to enforce the container budget in
this case ourselves with an enforcement timer. Furthermore, we also have
to update the exec_time ourselves since only actual task have their
exec_time updated automatically by litmus

the new functions are added and gschedule changed to fix the above
problem

1 files changed, 60 insertions, 2 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index 125b2e314176..449d6b3431a2 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -32,6 +32,8 @@ typedef struct cont_domain {
         lt_t changed_budget; //change to scheduled task's exec time due to container budget constraints

         u64 f_util, future_f_util;

         struct bheap_node *hn;

+    struct hrtimer idle_enforcement_timer;

+    int timer_armed;

 } cont_domain_t;

 

 typedef struct {

@@ -458,6 +460,7 @@ static int fifo_prio(struct bheap_node* _a, struct bheap_node* _b)
 // takes in the container_domain pointer in container task_struct

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

 // global lock in effect

+// returns container if no fixed task is next

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

 {

         rt_domain_t *edf = &cedf->domain;

@@ -576,7 +579,31 @@ static struct task_struct* edfsc_cschedule(cont_domain_t* cedf, struct task_stru
 

         printk("/edfsc_cschedule\n");

 

-        return next;

+        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;

+    if (t && budget_precisely_enforced(t)) {

+        BUG_ON(budget_exhausted(t) && !is_np(t));

+        if (likely(!is_np(t))) {

+            now = litmus_clock();

+            //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;

+            domain->scheduled_last_exec_time = now;

+        }

+    }

+    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

@@ -603,6 +630,12 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
         BUG_ON(entry->scheduled && !is_realtime(prev));

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

 

+    //TODO

+    // condition when a container is "scheduled" but there are no realtime tasks

+    if (is_container(entry->scheduled) && (!prev || !is_realtime(prev)))

+        tsk_rt(entry->scheduled)->job_params.exec_time += litmus_clock()

+            - tsk_rt(entry->scheduled)->edfsc_params.domain->scheduled_last_exec_time;

+

         // update container budget if prev was a fixed or background scheduled task

         if (entry->scheduled && prev && is_realtime(prev) && prev != entry->scheduled) {

                 // FIXME prev or entry->scheduled can be NULL, right?

@@ -723,7 +756,14 @@ static struct task_struct *edfsc_gschedule(struct task_struct *prev)
                 TRACE("becomes idle at %llu.\n", litmus_clock());

 #endif

 

-        return next;

+    if (is_container(next)) {

+        if (budget_precisely_enforced(next)) {

+            manage_idle_enforcement_timer(next);

+        }

+        return NULL;

+    }

+    else

+            return next;

 }

 

 /*

@@ -940,6 +980,7 @@ static void edfsc_task_new(struct task_struct* t, int on_rq, int is_scheduled)
                  * nothing was running before, update our state, and then reschedule.

                  * The task will be fixed to a container during the reschedule.

                  */

+        //Something needs fixing here

                 BUG_ON(entry->scheduled);

                 entry->scheduled = t;

                 preempt(entry);

@@ -1111,6 +1152,20 @@ 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)

 {

@@ -1141,6 +1196,8 @@ static int __init init_edfsc(void)
         edf_domain_init(&container_domains[i].domain, c_check_resched, NULL);

                 container_domains[i].scheduled = NULL;

         container_domains[i].container = &container_tasks[i];

+        hrtimer_init(&(container_domains[i].idle_enforcement_timer), CLOCK_MONOTONIC, HRTIMER_MODE_ABS);

+        container_domains[i].idle_enforcement_timer.function = on_idle_enforcement_timeout;

 

         container_tasks[i].policy = SCHED_LITMUS;

                 tsk_rt(&container_tasks[i])->scheduled_on = NO_CPU;

@@ -1149,6 +1206,7 @@ static int __init init_edfsc(void)
             LITMUS_QUANTUM_LENGTH_NS;

         tsk_rt(&container_tasks[i])->task_params.relative_deadline =

             LITMUS_QUANTUM_LENGTH_NS;

+        tsk_rt(&container_tasks[i])->task_params.budget_policy == PRECISE_ENFORCEMENT;

                 tsk_rt(&container_tasks[i])->edfsc_params.container_task = NULL;

         tsk_rt(&container_tasks[i])->domain = &gsched_domain;

                 tsk_rt(&container_tasks[i])->edfsc_params.domain = &container_domains[i];