EDF-WM: cleanup names a bit

1 files changed, 52 insertions, 55 deletions

diff --git a/litmus/sched_edf_wm.c b/litmus/sched_edf_wm.c
index ac0d2177eb7e..ed8cc24e9fe6 100644
--- a/litmus/sched_edf_wm.c
+++ b/litmus/sched_edf_wm.c
@@ -34,13 +34,11 @@ DEFINE_PER_CPU(wm_domain_t, wm_domains);
 
 #define TRACE_DOM(dom, fmt, args...) \
         TRACE("(wm_domains[%d]) " fmt, (dom)->cpu, ##args)
-#define local_edf               (&__get_cpu_var(wm_domains).domain)
-#define local_pedf              (&__get_cpu_var(wm_domains))
-#define remote_edf(cpu)         (&per_cpu(wm_domains, cpu).domain)
-#define remote_pedf(cpu)        (&per_cpu(wm_domains, cpu))
-#define task_edf(task)          remote_edf(get_partition(task))
-#define task_pedf(task)         remote_pedf(get_partition(task))
 
+
+#define local_domain         (&__get_cpu_var(wm_domains))
+#define remote_domain(cpu)   (&per_cpu(wm_domains, cpu))
+#define domain_of_task(task) (remote_domain(get_partition(task)))
 #define domain_from_timer(t) (container_of((t), wm_domain_t, enforcement_timer))
 
 /* we assume the lock is being held */
@@ -98,13 +96,13 @@ static void requeue(struct task_struct* t, rt_domain_t *edf)
  */
 static int wm_check_resched(rt_domain_t *edf)
 {
-        wm_domain_t *pedf = container_of(edf, wm_domain_t, domain);
+        wm_domain_t *dom = container_of(edf, wm_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, dom->scheduled)) {
+                preempt(dom);
                 return 1;
         } else
                 return 0;
@@ -121,13 +119,13 @@ static void job_completion(struct task_struct* t, int forced)
 
 static void wm_tick(struct task_struct *t)
 {
-        wm_domain_t *pedf = local_pedf;
+        wm_domain_t *dom = local_domain;
 
         /* 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 != dom->scheduled);
 
         if (is_realtime(t) && budget_enforced(t) && budget_exhausted(t)) {
                 if (!is_np(t)) {
@@ -146,30 +144,30 @@ static void wm_tick(struct task_struct *t)
 
 static struct task_struct* wm_schedule(struct task_struct * prev)
 {
-        wm_domain_t*    pedf = local_pedf;
-        rt_domain_t*            edf  = &pedf->domain;
+        wm_domain_t*            dom = local_domain;
+        rt_domain_t*            edf = &dom->domain;
         struct task_struct*     next;
 
         int                     out_of_time, sleep, preempt,
                                 np, exists, blocks, resched;
 
-        raw_spin_lock(&pedf->slock);
+        raw_spin_lock(&dom->slock);
 
         /* sanity checking
          * differently from gedf, when a task exits (dead)
-         * pedf->schedule may be null and prev _is_ realtime
+         * dom->schedule may be null and prev _is_ realtime
          */
-        BUG_ON(pedf->scheduled && pedf->scheduled != prev);
-        BUG_ON(pedf->scheduled && !is_realtime(prev));
+        BUG_ON(dom->scheduled && dom->scheduled != prev);
+        BUG_ON(dom->scheduled && !is_realtime(prev));
 
         /* (0) Determine state */
-        exists      = pedf->scheduled != NULL;
-        blocks      = exists && !is_running(pedf->scheduled);
+        exists      = dom->scheduled != NULL;
+        blocks      = exists && !is_running(dom->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(dom->scheduled) &&
+                                  budget_exhausted(dom->scheduled);
+        np          = exists && is_np(dom->scheduled);
+        sleep       = exists && get_rt_flags(dom->scheduled) == RT_F_SLEEP;
         preempt     = edf_preemption_needed(edf, prev);
 
         /* If we need to preempt do so.
@@ -187,14 +185,14 @@ static struct task_struct* wm_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(dom->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(dom->scheduled, !sleep);
                 resched = 1;
         }
 
@@ -207,8 +205,8 @@ static struct task_struct* wm_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 (dom->scheduled && !blocks)
+                        requeue(dom->scheduled, edf);
                 next = __take_ready(edf);
         } else
                 /* Only override Linux scheduler if we have a real-time task
@@ -224,8 +222,8 @@ static struct task_struct* wm_schedule(struct task_struct * prev)
                 TRACE("becoming idle at %llu\n", litmus_clock());
         }
 
-        pedf->scheduled = next;
-        raw_spin_unlock(&pedf->slock);
+        dom->scheduled = next;
+        raw_spin_unlock(&dom->slock);
 
         return next;
 }
@@ -235,9 +233,9 @@ static struct task_struct* wm_schedule(struct task_struct * prev)
  */
 static void wm_task_new(struct task_struct * t, int on_rq, int running)
 {
-        rt_domain_t*            edf  = task_edf(t);
-        wm_domain_t*    pedf = task_pedf(t);
-        unsigned long           flags;
+        wm_domain_t* dom = domain_of_task(t);
+        rt_domain_t* edf = &dom->domain;
+        unsigned long flags;
 
         TRACE_TASK(t, "psn edf: task new, cpu = %d\n",
                    t->rt_param.task_params.cpu);
@@ -248,28 +246,28 @@ static void wm_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(&dom->slock, flags);
         if (running) {
                 /* there shouldn't be anything else running at the time */
-                BUG_ON(pedf->scheduled);
-                pedf->scheduled = t;
+                BUG_ON(dom->scheduled);
+                dom->scheduled = t;
         } else {
                 requeue(t, edf);
                 /* maybe we have to reschedule */
-                preempt(pedf);
+                preempt(dom);
         }
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_spin_unlock_irqrestore(&dom->slock, flags);
 }
 
 static void wm_task_wake_up(struct task_struct *task)
 {
-        unsigned long           flags;
-        wm_domain_t*    pedf = task_pedf(task);
-        rt_domain_t*            edf  = task_edf(task);
-        lt_t                    now;
+        unsigned long flags;
+        wm_domain_t* dom = domain_of_task(task);
+        rt_domain_t* edf = &dom->domain;
+        lt_t now;
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_spin_lock_irqsave(&dom->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
@@ -291,10 +289,10 @@ static void wm_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 (dom->scheduled != task)
                 requeue(task, edf);
 
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        raw_spin_unlock_irqrestore(&dom->slock, flags);
         TRACE_TASK(task, "wake up done\n");
 }
 
@@ -310,22 +308,21 @@ static void wm_task_block(struct task_struct *t)
 static void wm_task_exit(struct task_struct * t)
 {
         unsigned long flags;
-        wm_domain_t*    pedf = task_pedf(t);
-        rt_domain_t*            edf;
+        wm_domain_t* dom = domain_of_task(t);
+        rt_domain_t* edf = &dom->domain;
 
-        raw_spin_lock_irqsave(&pedf->slock, flags);
+        raw_spin_lock_irqsave(&dom->slock, flags);
         if (is_queued(t)) {
                 /* dequeue */
-                edf  = task_edf(t);
                 remove(edf, t);
         }
-        if (pedf->scheduled == t)
-                pedf->scheduled = NULL;
+        if (dom->scheduled == t)
+                dom->scheduled = NULL;
 
         TRACE_TASK(t, "RIP, now reschedule\n");
 
-        preempt(pedf);
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+        preempt(dom);
+        raw_spin_unlock_irqrestore(&dom->slock, flags);
 }
 
 static long wm_admit_task(struct task_struct* tsk)
@@ -359,9 +356,9 @@ static int __init init_edf_wm(void)
          * we cannot use num_online_cpu()
          */
         for (i = 0; i < num_online_cpus(); i++) {
-                wm_domain_init(remote_pedf(i),
-                                   wm_check_resched,
-                                   NULL, i);
+                wm_domain_init(remote_domain(i),
+                               wm_check_resched,
+                               NULL, i);
         }
         return register_sched_plugin(&edf_wm_plugin);
 }