Added timer functionality to edf-wm scheduler

Added functions required for timer control to the current scheduler.
Still, it does not support migrations and works same as PSN-EDF.

1 files changed, 76 insertions, 62 deletions

diff --git a/litmus/sched_edf_wm.c b/litmus/sched_edf_wm.c
index c6fa1d3d30bf..5bfe5df0de90 100644
--- a/litmus/sched_edf_wm.c
+++ b/litmus/sched_edf_wm.c
@@ -30,27 +30,41 @@ typedef struct {
  * protects the domain and serializes scheduling decisions
  */
 #define slock domain.ready_lock
-
+/* HRTIMER: set for a subjob. We also need to set a flag, as tick() may be called by linux scheduler, and also the timer might go off before subjob has finished execution, and in that case we need to set the timer again*/
+        struct hrtimer timer;
+        int timer_flag;
+        lt_t end_timer;
 } edfwm_domain_t;
 
 DEFINE_PER_CPU(edfwm_domain_t, edfwm_domains);
 
-#define local_edf               (&__get_cpu_var(edfwm_domains).domain)
-#define local_pedf              (&__get_cpu_var(edfwm_domains))
-#define remote_edf(cpu)         (&per_cpu(edfwm_domains, cpu).domain)
-#define remote_pedf(cpu)        (&per_cpu(edfwm_domains, cpu))
-#define task_edf(task)          remote_edf(get_partition(task))
-#define task_pedf(task)         remote_pedf(get_partition(task))
+#define local_edf               (&__get_cpu_var(edfwm_domains).domain)
+#define local_edfwm             (&__get_cpu_var(edfwm_domains))
+#define remote_edf(cpu)         (&per_cpu(edfwm_domains, cpu).domain)
+#define remote_edfwm(cpu)       (&per_cpu(edfwm_domains, cpu))
+#define task_edf(task)          remote_edf(get_partition(task))
+#define task_edfwm(task)        remote_edfwm(get_partition(task))
 
+static enum hrtimer_restart on_release_timer(struct hrtimer *timer)
+{
+                scheduler_tick();
+                        return HRTIMER_NORESTART;
+}
 
-static void edfwm_domain_init(edfwm_domain_t* pedf,
+static void edfwm_domain_init(edfwm_domain_t* edfwm,
                                check_resched_needed_t check,
                                release_jobs_t release,
                                int cpu)
 {
-        edf_domain_init(&pedf->domain, check, release);
-        pedf->cpu               = cpu;
-        pedf->scheduled         = NULL;
+        edf_domain_init(&edfwm->domain, check, release);
+        edfwm->cpu                      = cpu;
+        edfwm->scheduled                = NULL;
+//        edfwm->block            = 0;
+
+        hrtimer_init(&edfwm->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+        edfwm->timer.function   = on_release_timer;
+        edfwm->end_timer = 0;
+        edfwm->timer_flag = 0;
 }
 
 static void requeue(struct task_struct* t, rt_domain_t *edf)
@@ -66,9 +80,9 @@ static void requeue(struct task_struct* t, rt_domain_t *edf)
 }
 
 /* we assume the lock is being held */
-static void preempt(edfwm_domain_t *pedf)
+static void preempt(edfwm_domain_t *edfwm)
 {
-        preempt_if_preemptable(pedf->scheduled, pedf->cpu);
+        preempt_if_preemptable(edfwm->scheduled, edfwm->cpu);
 }
 
 /* This check is trivial in partioned systems as we only have to consider
@@ -76,13 +90,13 @@ static void preempt(edfwm_domain_t *pedf)
  */
 static int edfwm_check_resched(rt_domain_t *edf)
 {
-        edfwm_domain_t *pedf = container_of(edf, edfwm_domain_t, domain);
+        edfwm_domain_t *edfwm = container_of(edf, edfwm_domain_t, domain);
 
         /* because this is a callback from rt_domain_t we already hold
          * the necessary lock for the ready queue
          */
-        if (edf_preemption_needed(edf, pedf->scheduled)) {
-                preempt(pedf);
+        if (edf_preemption_needed(edf, edfwm->scheduled)) {
+                preempt(edfwm);
                 return 1;
         } else
                 return 0;
@@ -99,13 +113,13 @@ static void job_completion(struct task_struct* t, int forced)
 
 static void edfwm_tick(struct task_struct *t)
 {
-        edfwm_domain_t *pedf = local_pedf;
+        edfwm_domain_t *edfwm = local_edfwm;
 
         /* Check for inconsistency. We don't need the lock for this since
          * ->scheduled is only changed in schedule, which obviously is not
          *  executing in parallel on this CPU
          */
-        BUG_ON(is_realtime(t) && t != pedf->scheduled);
+        BUG_ON(is_realtime(t) && t != edfwm->scheduled);
 
         if (is_realtime(t) && budget_enforced(t) && budget_exhausted(t)) {
                 if (!is_np(t)) {
@@ -124,30 +138,30 @@ static void edfwm_tick(struct task_struct *t)
 
 static struct task_struct* edfwm_schedule(struct task_struct * prev)
 {
-        edfwm_domain_t*         pedf = local_pedf;
-        rt_domain_t*            edf  = &pedf->domain;
+        edfwm_domain_t*         edfwm = local_edfwm;
+        rt_domain_t*            edf  = &edfwm->domain;
         struct task_struct*     next;
 
         int                     out_of_time, sleep, preempt,
                                 np, exists, blocks, resched;
 
-        raw_spin_lock(&pedf->slock);
+        raw_spin_lock(&edfwm->slock);
 
         /* sanity checking
          * differently from gedf, when a task exits (dead)
-         * pedf->schedule may be null and prev _is_ realtime
+         * edfwm->schedule may be null and prev _is_ realtime
          */
-        BUG_ON(pedf->scheduled && pedf->scheduled != prev);
-        BUG_ON(pedf->scheduled && !is_realtime(prev));
+        BUG_ON(edfwm->scheduled && edfwm->scheduled != prev);
+        BUG_ON(edfwm->scheduled && !is_realtime(prev));
 
         /* (0) Determine state */
-        exists      = pedf->scheduled != NULL;
-        blocks      = exists && !is_running(pedf->scheduled);
+        exists      = edfwm->scheduled != NULL;
+        blocks      = exists && !is_running(edfwm->scheduled);
         out_of_time = exists &&
-                                  budget_enforced(pedf->scheduled) &&
-                                  budget_exhausted(pedf->scheduled);
-        np          = exists && is_np(pedf->scheduled);
-        sleep       = exists && get_rt_flags(pedf->scheduled) == RT_F_SLEEP;
+                                  budget_enforced(edfwm->scheduled) &&
+                                  budget_exhausted(edfwm->scheduled);
+        np          = exists && is_np(edfwm->scheduled);
+        sleep       = exists && get_rt_flags(edfwm->scheduled) == RT_F_SLEEP;
         preempt     = edf_preemption_needed(edf, prev);
 
         /* If we need to preempt do so.
@@ -165,14 +179,14 @@ static struct task_struct* edfwm_schedule(struct task_struct * prev)
          * Multiple calls to request_exit_np() don't hurt.
          */
         if (np && (out_of_time || preempt || sleep))
-                request_exit_np(pedf->scheduled);
+                request_exit_np(edfwm->scheduled);
 
         /* Any task that is preemptable and either exhausts its execution
          * budget or wants to sleep completes. We may have to reschedule after
          * this.
          */
         if (!np && (out_of_time || sleep) && !blocks) {
-                job_completion(pedf->scheduled, !sleep);
+                job_completion(edfwm->scheduled, !sleep);
                 resched = 1;
         }
 
@@ -185,8 +199,8 @@ static struct task_struct* edfwm_schedule(struct task_struct * prev)
                 /* Take care of a previously scheduled
                  * job by taking it out of the Linux runqueue.
                  */
-                if (pedf->scheduled && !blocks)
-                        requeue(pedf->scheduled, edf);
+                if (edfwm->scheduled && !blocks)
+                        requeue(edfwm->scheduled, edf);
                 next = __take_ready(edf);
         } else
                 /* Only override Linux scheduler if we have a real-time task
@@ -202,8 +216,8 @@ static struct task_struct* edfwm_schedule(struct task_struct * prev)
                 TRACE("becoming idle at %llu\n", litmus_clock());
         }
 
-        pedf->scheduled = next;
-        raw_spin_unlock(&pedf->slock);
+        edfwm->scheduled = next;
+        raw_spin_unlock(&edfwm->slock);
 
         return next;
 }
@@ -214,7 +228,7 @@ static struct task_struct* edfwm_schedule(struct task_struct * prev)
 static void edfwm_task_new(struct task_struct * t, int on_rq, int running)
 {
         rt_domain_t*            edf  = task_edf(t);
-        edfwm_domain_t*         pedf = task_pedf(t);
+        edfwm_domain_t*         edfwm = task_edfwm(t);
         unsigned long           flags;
 
         TRACE_TASK(t, "edf-wm: task new, cpu = %d\n",
@@ -226,28 +240,28 @@ static void edfwm_task_new(struct task_struct * t, int on_rq, int running)
         /* The task should be running in the queue, otherwise signal
          * code will try to wake it up with fatal consequences.
          */
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_spin_lock_irqsave(&edfwm->slock, flags);
         if (running) {
                 /* there shouldn't be anything else running at the time */
-                BUG_ON(pedf->scheduled);
-                pedf->scheduled = t;
+                BUG_ON(edfwm->scheduled);
+                edfwm->scheduled = t;
         } else {
                 requeue(t, edf);
                 /* maybe we have to reschedule */
-                preempt(pedf);
+                preempt(edfwm);
         }
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_spin_unlock_irqrestore(&edfwm->slock, flags);
 }
 
 static void edfwm_task_wake_up(struct task_struct *task)
 {
         unsigned long           flags;
-        edfwm_domain_t*         pedf = task_pedf(task);
+        edfwm_domain_t*         edfwm = task_edfwm(task);
         rt_domain_t*            edf  = task_edf(task);
         lt_t                    now;
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_spin_lock_irqsave(&edfwm->slock, flags);
         BUG_ON(is_queued(task));
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
@@ -269,10 +283,10 @@ static void edfwm_task_wake_up(struct task_struct *task)
          * de-scheduling the task, i.e., wake_up() raced with schedule()
          * and won.
          */
-        if (pedf->scheduled != task)
+        if (edfwm->scheduled != task)
                 requeue(task, edf);
 
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_spin_unlock_irqrestore(&edfwm->slock, flags);
         TRACE_TASK(task, "wake up done\n");
 }
 
@@ -288,29 +302,29 @@ static void edfwm_task_block(struct task_struct *t)
 static void edfwm_task_exit(struct task_struct * t)
 {
         unsigned long flags;
-        edfwm_domain_t*         pedf = task_pedf(t);
+        edfwm_domain_t*         edfwm = task_edfwm(t);
         rt_domain_t*            edf;
 
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_spin_lock_irqsave(&edfwm->slock, flags);
         if (is_queued(t)) {
                 /* dequeue */
                 edf  = task_edf(t);
                 remove(edf, t);
         }
-        if (pedf->scheduled == t)
-                pedf->scheduled = NULL;
+        if (edfwm->scheduled == t)
+                edfwm->scheduled = NULL;
 
         TRACE_TASK(t, "RIP, now reschedule\n");
 
-        preempt(pedf);
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        preempt(edfwm);
+        raw_spin_unlock_irqrestore(&edfwm->slock, flags);
 }
 
 #ifdef CONFIG_FMLP
 static long edfwm_pi_block(struct pi_semaphore *sem,
                             struct task_struct *new_waiter)
 {
-        edfwm_domain_t*         pedf;
+        edfwm_domain_t*         edfwm;
         rt_domain_t*            edf;
         struct task_struct*     t;
         int cpu  = get_partition(new_waiter);
@@ -319,11 +333,11 @@ static long edfwm_pi_block(struct pi_semaphore *sem,
 
         if (edf_higher_prio(new_waiter, sem->hp.cpu_task[cpu])) {
                 TRACE_TASK(new_waiter, " boosts priority\n");
-                pedf = task_pedf(new_waiter);
+                edfwm = task_edfwm(new_waiter);
                 edf  = task_edf(new_waiter);
 
                 /* interrupts already disabled */
-                raw_spin_lock(&pedf->slock);
+                raw_spin_lock(&edfwm->slock);
 
                 /* store new highest-priority task */
                 sem->hp.cpu_task[cpu] = new_waiter;
@@ -346,9 +360,9 @@ static long edfwm_pi_block(struct pi_semaphore *sem,
 
                 /* check if we need to reschedule */
                 if (edf_preemption_needed(edf, current))
-                        preempt(pedf);
+                        preempt(edfwm);
 
-                raw_spin_unlock(&pedf->slock);
+                raw_spin_unlock(&edfwm->slock);
         }
 
         return 0;
@@ -383,7 +397,7 @@ static long edfwm_inherit_priority(struct pi_semaphore *sem,
 static long edfwm_return_priority(struct pi_semaphore *sem)
 {
         struct task_struct*     t    = current;
-        edfwm_domain_t*         pedf = task_pedf(t);
+        edfwm_domain_t*         edfwm = task_edfwm(t);
         rt_domain_t*            edf  = task_edf(t);
         int                     ret  = 0;
         int                     cpu  = get_partition(current);
@@ -415,16 +429,16 @@ static long edfwm_return_priority(struct pi_semaphore *sem)
         /* Always check for delayed preemptions that might have become
          * necessary due to non-preemptive execution.
          */
-        raw_spin_lock(&pedf->slock);
+        raw_spin_lock(&edfwm->slock);
 
         /* Reset inh_task to NULL. */
         current->rt_param.inh_task = NULL;
 
         /* check if we need to reschedule */
         if (edf_preemption_needed(edf, current))
-                preempt(pedf);
+                preempt(edfwm);
 
-        raw_spin_unlock(&pedf->slock);
+        raw_spin_unlock(&edfwm->slock);
 
 
         return ret;
@@ -469,7 +483,7 @@ static int __init init_edf_wm(void)
          * we cannot use num_online_cpu()
          */
         for (i = 0; i < num_online_cpus(); i++) {
-                edfwm_domain_init(remote_pedf(i),
+                edfwm_domain_init(remote_edfwm(i),
                                    edfwm_check_resched,
                                    NULL, i);
         }