[EDF-fm] Remove code uglyness and properly initialize jobno

- Remove stale comments in the code.
- Remove non needed checks and add proper invariants.
- Increment per-cpu job number when a task is released (task_new). This
  removes the need of detecting the 'first' job.

1 files changed, 9 insertions, 54 deletions

diff --git a/litmus/sched_edf_fm.c b/litmus/sched_edf_fm.c
index 8eb7b9c12237..70c5d289288f 100644
--- a/litmus/sched_edf_fm.c
+++ b/litmus/sched_edf_fm.c
@@ -91,8 +91,7 @@ int edffm_higher_prio(struct task_struct* first, struct task_struct* second)
 }
 
 /* need_to_preempt - check whether the task t needs to be preempted
- *                   call only with irqs disabled and with  ready_lock acquired
- *                   THIS DOES NOT TAKE NON-PREEMPTIVE SECTIONS INTO ACCOUNT!
+ *                   call only with irqs disabled and with ready_lock acquired
  */
 int edffm_preemption_needed(rt_domain_t* rt, struct task_struct *t)
 {
@@ -187,10 +186,6 @@ static noinline void insert_task_in_remote_ready(struct task_struct *task)
 {
         edffm_domain_t *this = remote_edffm(task_cpu(task));
         edffm_domain_t *remote = remote_edffm(get_partition(task));
-        /* FIXME we don't drop the rqlock, so this task shouldn't change
-         * This function shouldn't be called by a wakeup (as the job hasn't
-         * completed yet) */
-        struct task_struct *old;
 
         BUG_ON(get_partition(task) != remote->cpu);
 
@@ -198,7 +193,6 @@ static noinline void insert_task_in_remote_ready(struct task_struct *task)
                         this->cpu, remote->cpu);
         TRACE_TASK(task, "Inserting in remote ready queue\n");
 
-        old = task;
         WARN_ON(!irqs_disabled());
 
         raw_spin_unlock(&this->slock);
@@ -215,13 +209,6 @@ static noinline void insert_task_in_remote_ready(struct task_struct *task)
         raw_spin_unlock(&remote->slock);
         TRACE_TASK(task,"edffm_lock %d released\n", remote->cpu);
 
-        if (old != task) {
-                TRACE_TASK(task,"Task changed while we dropped"
-                                " the lock: old = (0x%p),"
-                                " cur = (0x%p)\n",
-                                old, task);
-        }
-
         /* ask remote cpu to reschedule, we are already rescheduling on this */
         preempt(remote);
 }
@@ -262,23 +249,12 @@ static void requeue(struct task_struct* t, rt_domain_t *edf)
 /* Update statistics for the _current_ job.
  *      - job_no was incremented _before_ starting this job
  *      (release_at / prepare_for_next_period)
- *      - job_no can be incremented several times before what we consider
- *      to be the 'true' release. FIXME: this has the side effect of
- *      discarding the first job...
+ *      - cpu_job_no is incremented when the job completes
  */
 static void update_job_counter(struct task_struct *t)
 {
         int cpu_pos;
 
-        /* We need a precise accounting for job numbers; when the first real
-         * job completes, both job CPU conters are 0; we reset job_no counter
-         */
-        if (tsk_rt(t)->job_params.cpu_job_no[0] == 0 &&
-                        tsk_rt(t)->job_params.cpu_job_no[1] == 0) {
-                /* first "real job" has executed once */
-                t->rt_param.job_params.job_no = 1;
-        }
-
         /* Which CPU counter should be incremented? */
         cpu_pos = edffm_cpu_pos(t->rt_param.task_params.cpu, t);
         t->rt_param.job_params.cpu_job_no[cpu_pos]++;
@@ -288,14 +264,11 @@ static void update_job_counter(struct task_struct *t)
                         t->rt_param.task_params.cpu);
 }
 
-/* What is the next cpu for this job? (eq. 8) */
+/* What is the next cpu for this job? (eq. 8, in EDF-Fm paper) */
 static int next_cpu_for_job(struct task_struct *t)
 {
         BUG_ON(!is_migrat_task(t));
 
-        /* update_job_counter() reset job_no to 1
-         * when the first "real" job is detected
-         */
         if ((t->rt_param.job_params.job_no) ==
                         (((lt_t) cur_cpu_job_no(t) * cur_cpu_fract_den(t)) /
                         cur_cpu_fract_num(t)))
@@ -365,10 +338,6 @@ static struct task_struct* edffm_schedule(struct task_struct * prev)
 
         raw_spin_lock(&edffm->slock);
 
-        /* sanity checking
-         * differently from gedf, when a task exits (dead)
-         * edffm->schedule may be null and prev _is_ realtime
-         */
         BUG_ON(edffm->scheduled && edffm->scheduled != prev);
         BUG_ON(edffm->scheduled && !is_realtime(prev));
 
@@ -382,10 +351,7 @@ static struct task_struct* edffm_schedule(struct task_struct * prev)
         change_cpu  = exists && wrong_cpu(edffm->scheduled);
         preempt     = edffm_preemption_needed(edf, prev);
 
-        /* FIXME can this happen??? */
-        if(blocks && change_cpu) {
-                TRACE_TASK(prev, "WARN: blocked, but should change CPU!\n");
-        }
+        BUG_ON(blocks && change_cpu);
 
         if (exists)
                 TRACE_TASK(prev,
@@ -394,14 +360,10 @@ static struct task_struct* edffm_schedule(struct task_struct * prev)
                            blocks, out_of_time, sleep, preempt,
                            change_cpu, prev->state, signal_pending(prev));
 
-        /* If we need to preempt do so.
-         * The following checks set resched to 1 in case of special
-         * circumstances.
-         */
+        /* If we need to preempt do so. */
         resched = preempt;
 
-        /* If a task blocks we have no choice but to reschedule.
-         */
+        /* If a task blocks we have no choice but to reschedule. */
         if (blocks)
                 resched = 1;
 
@@ -428,9 +390,7 @@ static struct task_struct* edffm_schedule(struct task_struct * prev)
          */
         next = NULL;
         if (resched || !exists) {
-                /* Take care of a previously scheduled
-                 * job by taking it out of the Linux runqueue.
-                 */
+
                 if (edffm->scheduled && !blocks)
                         requeue(edffm->scheduled, edf);
                 next = __take_ready(edf);
@@ -465,9 +425,8 @@ static void edffm_task_new(struct task_struct * t, int on_rq, int running)
         TRACE_TASK(t, "EDF-fm: task new, cpu = %d\n",
                    t->rt_param.task_params.cpu);
 
-        /* FIXME: setup job parameters, we will start counting 'real' jobs
-         * after the first completion */
         release_at(t, litmus_clock());
+        update_job_counter(t);
 
         /* The task should be running in the queue, otherwise signal
          * code will try to wake it up with fatal consequences.
@@ -531,7 +490,6 @@ static void edffm_task_wake_up(struct task_struct *task)
 
 static void edffm_task_block(struct task_struct *t)
 {
-        /* only running tasks can block, thus t is in no queue */
         TRACE_TASK(t, "block at %llu, state=%d\n", litmus_clock(), t->state);
 
         BUG_ON(!is_realtime(t));
@@ -587,10 +545,7 @@ static int __init init_edffm(void)
         int i;
         edffm_domain_t *edffm;
 
-        /* We do not really want to support cpu hotplug, do we? ;)
-         * However, if we are so crazy to do so,
-         * we cannot use num_online_cpu()
-         */
+        /* Note, broken if num_online_cpus() may change */
         for (i = 0; i < num_online_cpus(); i++) {
                 edffm = remote_edffm(i);
                 edffm->cpu = i;