Copy and rename gsn-edf -> cedf

1 files changed, 387 insertions, 286 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index d0767ce9e178..0dace2dc871f 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -1,9 +1,7 @@
 /*
- * kernel/sched_cedf.c
+ * litmus/sched_cedf.c
  *
- * Implementation of the Clustered EDF (C-EDF) scheduling algorithm.
- * Linking is included so that support for synchronization (e.g., through
- * the implementation of a "CSN-EDF" algorithm) can be added later if desired.
+ * Implementation of the C-EDF scheduling algorithm.
  *
  * This version uses the simple approach and serializes all scheduling
  * decisions by the use of a queue lock. This is probably not the
@@ -13,19 +11,23 @@
 #include <linux/spinlock.h>
 #include <linux/percpu.h>
 #include <linux/sched.h>
-#include <linux/list.h>
 
 #include <litmus/litmus.h>
 #include <litmus/jobs.h>
 #include <litmus/sched_plugin.h>
 #include <litmus/edf_common.h>
 #include <litmus/sched_trace.h>
+
 #include <litmus/bheap.h>
 
 #include <linux/module.h>
 
 /* Overview of C-EDF operations.
  *
+ * For a detailed explanation of C-EDF have a look at the FMLP paper. This
+ * description only covers how the individual operations are implemented in
+ * LITMUS.
+ *
  * link_task_to_cpu(T, cpu)     - Low-level operation to update the linkage
  *                                structure (NOT the actually scheduled
  *                                task). If there is another linked task To
@@ -42,10 +44,9 @@
  * unlink(T)                    - Unlink removes T from all scheduler data
  *                                structures. If it is linked to some CPU it
  *                                will link NULL to that CPU. If it is
- *                                currently queued in the cedf queue for
- *                                a partition, it will be removed from
- *                                the rt_domain. It is safe to call
- *                                unlink(T) if T is not linked. T may not
+ *                                currently queued in the cedf queue it will
+ *                                be removed from the rt_domain. It is safe to
+ *                                call unlink(T) if T is not linked. T may not
  *                                be NULL.
  *
  * requeue(T)                   - Requeue will insert T into the appropriate
@@ -56,11 +57,11 @@
  *                                release queue. If T's release time is in the
  *                                future, it will go into the release
  *                                queue. That means that T's release time/job
- *                                no/etc. has to be updated before requeue(T) is
+ *                                no/etc. has to be updated before requeu(T) is
  *                                called. It is not safe to call requeue(T)
  *                                when T is already queued. T may not be NULL.
  *
- * cedf_job_arrival(T)          - This is the catch-all function when T enters
+ * cedf_job_arrival(T)  - This is the catch all function when T enters
  *                                the system after either a suspension or at a
  *                                job release. It will queue T (which means it
  *                                is not safe to call cedf_job_arrival(T) if
@@ -71,7 +72,7 @@
  *                                (either with an IPI or need_resched). It is
  *                                safe to call cedf_job_arrival(T) if T's
  *                                next job has not been actually released yet
- *                                (release time in the future). T will be put
+ *                                (releast time in the future). T will be put
  *                                on the release queue in that case.
  *
  * job_completion(T)            - Take care of everything that needs to be done
@@ -87,18 +88,19 @@
  * __take_ready).
  */
 
+
 /* cpu_entry_t - maintain the linked and scheduled state
  */
 typedef struct  {
         int                     cpu;
         struct task_struct*     linked;         /* only RT tasks */
         struct task_struct*     scheduled;      /* only RT tasks */
-        struct list_head        list;
         atomic_t                will_schedule;  /* prevent unneeded IPIs */
+        struct bheap_node*      hn;
 } cpu_entry_t;
 DEFINE_PER_CPU(cpu_entry_t, cedf_cpu_entries);
 
-cpu_entry_t* *cedf_cpu_entries_array;
+cpu_entry_t* cedf_cpus[NR_CPUS];
 
 #define set_will_schedule() \
         (atomic_set(&__get_cpu_var(cedf_cpu_entries).will_schedule, 1))
@@ -107,75 +109,50 @@ cpu_entry_t* *cedf_cpu_entries_array;
 #define test_will_schedule(cpu) \
         (atomic_read(&per_cpu(cedf_cpu_entries, cpu).will_schedule))
 
-/* Cluster size -- currently four. This is a variable to allow for
- * the possibility of changing the cluster size online in the future.
- */
-int cluster_size = 4;
-
-int do_cleanup = 1;
-
-typedef struct {
-        rt_domain_t             domain;
-        int                     first_cpu;
-        int                     last_cpu;
 
-        /* the cpus queue themselves according to priority in here */
-        struct list_head        cedf_cpu_queue;
+/* the cpus queue themselves according to priority in here */
+static struct bheap_node cedf_heap_node[NR_CPUS];
+static struct bheap      cedf_cpu_heap;
 
-        /* per-partition spinlock: protects the domain and
-         * serializes scheduling decisions
-         */
-#define slock domain.ready_lock
-} cedf_domain_t;
-
-DEFINE_PER_CPU(cedf_domain_t*, cedf_domains) = NULL;
-
-cedf_domain_t* *cedf_domains_array;
+static rt_domain_t cedf;
+#define cedf_lock (cedf.ready_lock)
 
 
-/* These are defined similarly to partitioning, except that a
- * tasks partition is any cpu of the cluster to which it
- * is assigned, typically the lowest-numbered cpu.
+/* Uncomment this if you want to see all scheduling decisions in the
+ * TRACE() log.
+#define WANT_ALL_SCHED_EVENTS
  */
-#define local_edf               (&__get_cpu_var(cedf_domains)->domain)
-#define local_cedf              __get_cpu_var(cedf_domains)
-#define remote_edf(cpu)         (&per_cpu(cedf_domains, cpu)->domain)
-#define remote_cedf(cpu)        per_cpu(cedf_domains, cpu)
-#define task_edf(task)          remote_edf(get_partition(task))
-#define task_cedf(task)         remote_cedf(get_partition(task))
+
+static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
+{
+        cpu_entry_t *a, *b;
+        a = _a->value;
+        b = _b->value;
+        /* Note that a and b are inverted: we want the lowest-priority CPU at
+         * the top of the heap.
+         */
+        return edf_higher_prio(b->linked, a->linked);
+}
 
 /* update_cpu_position - Move the cpu entry to the correct place to maintain
  *                       order in the cpu queue. Caller must hold cedf lock.
- *
- *                                              This really should be a heap.
  */
 static void update_cpu_position(cpu_entry_t *entry)
 {
-        cpu_entry_t *other;
-        struct list_head *cedf_cpu_queue =
-                &(remote_cedf(entry->cpu))->cedf_cpu_queue;
-        struct list_head *pos;
-
-        BUG_ON(!cedf_cpu_queue);
+        if (likely(bheap_node_in_heap(entry->hn)))
+                bheap_delete(cpu_lower_prio, &cedf_cpu_heap, entry->hn);
+        bheap_insert(cpu_lower_prio, &cedf_cpu_heap, entry->hn);
+}
 
-        if (likely(in_list(&entry->list)))
-                list_del(&entry->list);
-        /* if we do not execute real-time jobs we just move
-         * to the end of the queue
-         */
-        if (entry->linked) {
-                list_for_each(pos, cedf_cpu_queue) {
-                        other = list_entry(pos, cpu_entry_t, list);
-                        if (edf_higher_prio(entry->linked, other->linked)) {
-                                __list_add(&entry->list, pos->prev, pos);
-                                return;
-                        }
-                }
-        }
-        /* if we get this far we have the lowest priority job */
-        list_add_tail(&entry->list, cedf_cpu_queue);
+/* caller must hold cedf lock */
+static cpu_entry_t* lowest_prio_cpu(void)
+{
+        struct bheap_node* hn;
+        hn = bheap_peek(cpu_lower_prio, &cedf_cpu_heap);
+        return hn->value;
 }
 
+
 /* link_task_to_cpu - Update the link of a CPU.
  *                    Handles the case where the to-be-linked task is already
  *                    scheduled on a different CPU.
@@ -189,9 +166,6 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
 
         BUG_ON(linked && !is_realtime(linked));
 
-        /* Cannot link task to a CPU that doesn't belong to its partition... */
-        BUG_ON(linked && remote_cedf(entry->cpu) != task_cedf(linked));
-
         /* Currently linked task is set to be unlinked. */
         if (entry->linked) {
                 entry->linked->rt_param.linked_on = NO_CPU;
@@ -213,6 +187,9 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                          * the caller to get things right.
                          */
                         if (entry != sched) {
+                                TRACE_TASK(linked,
+                                           "already scheduled on %d, updating link.\n",
+                                           sched->cpu);
                                 tmp = sched->linked;
                                 linked->rt_param.linked_on = sched->cpu;
                                 sched->linked = linked;
@@ -224,13 +201,12 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                         linked->rt_param.linked_on = entry->cpu;
         }
         entry->linked = linked;
-
-        if (entry->linked)
-                TRACE_TASK(entry->linked, "linked to CPU %d, state:%d\n",
-                           entry->cpu, entry->linked->state);
+#ifdef WANT_ALL_SCHED_EVENTS
+        if (linked)
+                TRACE_TASK(linked, "linked to %d.\n", entry->cpu);
         else
-                TRACE("NULL linked to CPU %d\n", entry->cpu);
-
+                TRACE("NULL linked to %d.\n", entry->cpu);
+#endif
         update_cpu_position(entry);
 }
 
@@ -259,94 +235,97 @@ static noinline void unlink(struct task_struct* t)
                  * queue. We must remove it from the list in this
                  * case.
                  */
-                remove(task_edf(t), t);
+                remove(&cedf, t);
         }
 }
 
 
 /* preempt - force a CPU to reschedule
  */
-static noinline void preempt(cpu_entry_t *entry)
+static void preempt(cpu_entry_t *entry)
 {
         preempt_if_preemptable(entry->scheduled, entry->cpu);
 }
 
-/* requeue - Put an unlinked task into c-edf domain.
+/* requeue - Put an unlinked task into gsn-edf domain.
  *           Caller must hold cedf_lock.
  */
 static noinline void requeue(struct task_struct* task)
 {
-        cedf_domain_t* cedf;
-        rt_domain_t* edf;
-
         BUG_ON(!task);
-        /* sanity check rt_list before insertion */
+        /* sanity check before insertion */
         BUG_ON(is_queued(task));
 
-        /* Get correct real-time domain. */
-        cedf = task_cedf(task);
-        edf = &cedf->domain;
-
         if (is_released(task, litmus_clock()))
-                __add_ready(edf, task);
+                __add_ready(&cedf, task);
         else {
                 /* it has got to wait */
-                add_release(edf, task);
+                add_release(&cedf, task);
         }
 }
 
-static void check_for_preemptions(cedf_domain_t* cedf)
+/* check for any necessary preemptions */
+static void check_for_preemptions(void)
 {
-        cpu_entry_t *last;
         struct task_struct *task;
-        struct list_head *cedf_cpu_queue;
-        cedf_cpu_queue = &cedf->cedf_cpu_queue;
+        cpu_entry_t* last;
 
-        for(last = list_entry(cedf_cpu_queue->prev, cpu_entry_t, list);
-            edf_preemption_needed(&cedf->domain, last->linked);
-            last = list_entry(cedf_cpu_queue->prev, cpu_entry_t, list)) {
+        for(last = lowest_prio_cpu();
+            edf_preemption_needed(&cedf, last->linked);
+            last = lowest_prio_cpu()) {
                 /* preemption necessary */
-                task = __take_ready(&cedf->domain);
-                TRACE("check_for_preemptions: task %d linked to %d, state:%d\n",
-                      task->pid, last->cpu, task->state);
+                task = __take_ready(&cedf);
+                TRACE("check_for_preemptions: attempting to link task %d to %d\n",
+                      task->pid, last->cpu);
                 if (last->linked)
                         requeue(last->linked);
                 link_task_to_cpu(task, last);
                 preempt(last);
         }
-
 }
 
 /* cedf_job_arrival: task is either resumed or released */
 static noinline void cedf_job_arrival(struct task_struct* task)
 {
-        cedf_domain_t* cedf;
-        rt_domain_t* edf;
-
         BUG_ON(!task);
 
-        /* Get correct real-time domain. */
-        cedf = task_cedf(task);
-        edf = &cedf->domain;
-
-        /* first queue arriving job */
         requeue(task);
-
-        /* then check for any necessary preemptions */
-        check_for_preemptions(cedf);
+        check_for_preemptions();
 }
 
-/* check for current job releases */
 static void cedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 {
-        cedf_domain_t*          cedf = container_of(rt, cedf_domain_t, domain);
-        unsigned long           flags;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cedf_lock, flags);
 
-        spin_lock_irqsave(&cedf->slock, flags);
+        __merge_ready(rt, tasks);
+        check_for_preemptions();
 
-        __merge_ready(&cedf->domain, tasks);
-        check_for_preemptions(cedf);
-        spin_unlock_irqrestore(&cedf->slock, flags);
+        spin_unlock_irqrestore(&cedf_lock, flags);
+}
+
+/* caller holds cedf_lock */
+static noinline void job_completion(struct task_struct *t, int forced)
+{
+        BUG_ON(!t);
+
+        sched_trace_task_completion(t, forced);
+
+        TRACE_TASK(t, "job_completion().\n");
+
+        /* set flags */
+        set_rt_flags(t, RT_F_SLEEP);
+        /* prepare for next period */
+        prepare_for_next_period(t);
+        if (is_released(t, litmus_clock()))
+                sched_trace_task_release(t);
+        /* unlink */
+        unlink(t);
+        /* requeue
+         * But don't requeue a blocking task. */
+        if (is_running(t))
+                cedf_job_arrival(t);
 }
 
 /* cedf_tick - this function is called for every local timer
@@ -357,8 +336,6 @@ static void cedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
  */
 static void cedf_tick(struct task_struct* t)
 {
-        BUG_ON(!t);
-
         if (is_realtime(t) && budget_exhausted(t)) {
                 if (!is_np(t)) {
                         /* np tasks will be preempted when they become
@@ -367,38 +344,17 @@ static void cedf_tick(struct task_struct* t)
                         set_tsk_need_resched(t);
                         set_will_schedule();
                         TRACE("cedf_scheduler_tick: "
-                              "%d is preemptable (state:%d) "
-                              " => FORCE_RESCHED\n", t->pid, t->state);
-                } else if(is_user_np(t)) {
+                              "%d is preemptable "
+                              " => FORCE_RESCHED\n", t->pid);
+                } else if (is_user_np(t)) {
                         TRACE("cedf_scheduler_tick: "
-                              "%d is non-preemptable (state:%d), "
-                              "preemption delayed.\n", t->pid, t->state);
+                              "%d is non-preemptable, "
+                              "preemption delayed.\n", t->pid);
                         request_exit_np(t);
                 }
         }
 }
 
-/* caller holds cedf_lock */
-static noinline void job_completion(struct task_struct *t, int forced)
-{
-        BUG_ON(!t);
-
-        sched_trace_task_completion(t, forced);
-
-        TRACE_TASK(t, "job_completion(). [state:%d]\n", t->state);
-
-        /* set flags */
-        set_rt_flags(t, RT_F_SLEEP);
-        /* prepare for next period */
-        prepare_for_next_period(t);
-        /* unlink */
-        unlink(t);
-        /* requeue
-         * But don't requeue a blocking task. */
-        if (is_running(t))
-                cedf_job_arrival(t);
-}
-
 /* Getting schedule() right is a bit tricky. schedule() may not make any
  * assumptions on the state of the current task since it may be called for a
  * number of reasons. The reasons include a scheduler_tick() determined that it
@@ -422,22 +378,17 @@ static noinline void job_completion(struct task_struct *t, int forced)
  */
 static struct task_struct* cedf_schedule(struct task_struct * prev)
 {
-        cedf_domain_t*          cedf = local_cedf;
-        rt_domain_t*            edf  = &cedf->domain;
-        cpu_entry_t*            entry = &__get_cpu_var(cedf_cpu_entries);
-        int                     out_of_time, sleep, preempt, np,
-                                exists, blocks;
-        struct task_struct*     next = NULL;
-
-        BUG_ON(!prev);
-        BUG_ON(!cedf);
-        BUG_ON(!edf);
-        BUG_ON(!entry);
-        BUG_ON(cedf != remote_cedf(entry->cpu));
-        BUG_ON(is_realtime(prev) && cedf != task_cedf(prev));
-
-        /* Will be released in finish_switch. */
-        spin_lock(&cedf->slock);
+        cpu_entry_t* entry = &__get_cpu_var(cedf_cpu_entries);
+        int out_of_time, sleep, preempt, np, exists, blocks;
+        struct task_struct* next = NULL;
+
+        /* Bail out early if we are the release master.
+         * The release master never schedules any real-time tasks.
+         */
+        if (cedf.release_master == entry->cpu)
+                return NULL;
+
+        spin_lock(&cedf_lock);
         clear_will_schedule();
 
         /* sanity checking */
@@ -453,6 +404,21 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
         sleep       = exists && get_rt_flags(entry->scheduled) == RT_F_SLEEP;
         preempt     = entry->scheduled != entry->linked;
 
+#ifdef WANT_ALL_SCHED_EVENTS
+        TRACE_TASK(prev, "invoked cedf_schedule.\n");
+#endif
+
+        if (exists)
+                TRACE_TASK(prev,
+                           "blocks:%d out_of_time:%d np:%d sleep:%d preempt:%d "
+                           "state:%d sig:%d\n",
+                           blocks, out_of_time, np, sleep, preempt,
+                           prev->state, signal_pending(prev));
+        if (entry->linked && preempt)
+                TRACE_TASK(prev, "will be preempted by %s/%d\n",
+                           entry->linked->comm, entry->linked->pid);
+
+
         /* If a task blocks we have no choice but to reschedule.
          */
         if (blocks)
@@ -470,8 +436,8 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
 
         /* Any task that is preemptable and either exhausts its execution
          * budget or wants to sleep completes. We may have to reschedule after
-         * this. Don't do a job completion if blocks (can't have timers
-         * running for blocked jobs). Preemption go first for the same reason.
+         * this. Don't do a job completion if we block (can't have timers running
+         * for blocked jobs). Preemption go first for the same reason.
          */
         if (!np && (out_of_time || sleep) && !blocks && !preempt)
                 job_completion(entry->scheduled, !sleep);
@@ -479,10 +445,10 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
         /* Link pending task if we became unlinked.
          */
         if (!entry->linked)
-                link_task_to_cpu(__take_ready(edf), entry);
+                link_task_to_cpu(__take_ready(&cedf), entry);
 
         /* The final scheduling decision. Do we need to switch for some reason?
-         * If linked different from scheduled select linked as next.
+         * If linked is different from scheduled, then select linked as next.
          */
         if ((!np || blocks) &&
             entry->linked != entry->scheduled) {
@@ -491,76 +457,90 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                         entry->linked->rt_param.scheduled_on = entry->cpu;
                         next = entry->linked;
                 }
-                if (entry->scheduled) {
+                if (entry->scheduled) {
                         /* not gonna be scheduled soon */
                         entry->scheduled->rt_param.scheduled_on = NO_CPU;
-                        TRACE_TASK(entry->scheduled, "cedf_schedule: scheduled_on = NO_CPU\n");
+                        TRACE_TASK(entry->scheduled, "scheduled_on = NO_CPU\n");
                 }
         } else
-                /* Only override Linux scheduler if we have real-time task
+                /* Only override Linux scheduler if we have a real-time task
                  * scheduled that needs to continue.
                  */
                 if (exists)
                         next = prev;
 
-        spin_unlock(&cedf->slock);
+        spin_unlock(&cedf_lock);
+
+#ifdef WANT_ALL_SCHED_EVENTS
+        TRACE("cedf_lock released, next=0x%p\n", next);
+
+        if (next)
+                TRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
+        else if (exists && !next)
+                TRACE("becomes idle at %llu.\n", litmus_clock());
+#endif
+
 
         return next;
 }
 
+
 /* _finish_switch - we just finished the switch away from prev
  */
 static void cedf_finish_switch(struct task_struct *prev)
 {
-        cpu_entry_t* entry = &__get_cpu_var(cedf_cpu_entries);
-
-        BUG_ON(!prev);
-        BUG_ON(!entry);
+        cpu_entry_t*    entry = &__get_cpu_var(cedf_cpu_entries);
 
         entry->scheduled = is_realtime(current) ? current : NULL;
+#ifdef WANT_ALL_SCHED_EVENTS
+        TRACE_TASK(prev, "switched away from\n");
+#endif
 }
 
+
 /*      Prepare a task for running in RT mode
  */
-static void cedf_task_new(struct task_struct *t, int on_rq, int running)
+static void cedf_task_new(struct task_struct * t, int on_rq, int running)
 {
         unsigned long           flags;
-        cedf_domain_t*          cedf = task_cedf(t);
         cpu_entry_t*            entry;
 
-        BUG_ON(!cedf);
+        TRACE("gsn edf: task new %d\n", t->pid);
+
+        spin_lock_irqsave(&cedf_lock, flags);
+
+        /* setup job params */
+        release_at(t, litmus_clock());
 
-        spin_lock_irqsave(&cedf->slock, flags);
         if (running) {
                 entry = &per_cpu(cedf_cpu_entries, task_cpu(t));
-                BUG_ON(!entry);
                 BUG_ON(entry->scheduled);
-                entry->scheduled = t;
-                t->rt_param.scheduled_on = task_cpu(t);
-        } else
-                t->rt_param.scheduled_on = NO_CPU;
-        t->rt_param.linked_on = NO_CPU;
 
-        /* setup job params */
-        release_at(t, litmus_clock());
+                if (entry->cpu != cedf.release_master) {
+                        entry->scheduled = t;
+                        tsk_rt(t)->scheduled_on = task_cpu(t);
+                } else {
+                        /* do not schedule on release master */
+                        preempt(entry); /* force resched */
+                        tsk_rt(t)->scheduled_on = NO_CPU;
+                }
+        } else {
+                t->rt_param.scheduled_on = NO_CPU;
+        }
+        t->rt_param.linked_on          = NO_CPU;
 
         cedf_job_arrival(t);
-        spin_unlock_irqrestore(&cedf->slock, flags);
+        spin_unlock_irqrestore(&cedf_lock, flags);
 }
 
-
 static void cedf_task_wake_up(struct task_struct *task)
 {
-        unsigned long           flags;
-        cedf_domain_t*          cedf;
-        lt_t                    now;
-
-        BUG_ON(!task);
+        unsigned long flags;
+        lt_t now;
 
-        cedf = task_cedf(task);
-        BUG_ON(!cedf);
+        TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
 
-        spin_lock_irqsave(&cedf->slock, flags);
+        spin_lock_irqsave(&cedf_lock, flags);
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
          * a semaphore, it should never be treated as a new job release.
@@ -574,59 +554,234 @@ static void cedf_task_wake_up(struct task_struct *task)
                         release_at(task, now);
                         sched_trace_task_release(task);
                 }
-                else if (task->rt.time_slice)
-                        /* came back in time before deadline
-                         */
-                        set_rt_flags(task, RT_F_RUNNING);
+                else {
+                        if (task->rt.time_slice) {
+                                /* came back in time before deadline
+                                */
+                                set_rt_flags(task, RT_F_RUNNING);
+                        }
+                }
         }
         cedf_job_arrival(task);
-        spin_unlock_irqrestore(&cedf->slock, flags);
+        spin_unlock_irqrestore(&cedf_lock, flags);
 }
 
-
 static void cedf_task_block(struct task_struct *t)
 {
         unsigned long flags;
 
-        BUG_ON(!t);
+        TRACE_TASK(t, "block at %llu\n", litmus_clock());
 
         /* unlink if necessary */
-        spin_lock_irqsave(&task_cedf(t)->slock, flags);
-
-        t->rt_param.scheduled_on = NO_CPU;
+        spin_lock_irqsave(&cedf_lock, flags);
         unlink(t);
-
-        spin_unlock_irqrestore(&task_cedf(t)->slock, flags);
+        spin_unlock_irqrestore(&cedf_lock, flags);
 
         BUG_ON(!is_realtime(t));
 }
 
+
 static void cedf_task_exit(struct task_struct * t)
 {
         unsigned long flags;
 
-        BUG_ON(!t);
-
         /* unlink if necessary */
-        spin_lock_irqsave(&task_cedf(t)->slock, flags);
+        spin_lock_irqsave(&cedf_lock, flags);
         unlink(t);
         if (tsk_rt(t)->scheduled_on != NO_CPU) {
-                cedf_cpu_entries_array[tsk_rt(t)->scheduled_on]->
-                        scheduled = NULL;
+                cedf_cpus[tsk_rt(t)->scheduled_on]->scheduled = NULL;
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
-        spin_unlock_irqrestore(&task_cedf(t)->slock, flags);
+        spin_unlock_irqrestore(&cedf_lock, flags);
 
         BUG_ON(!is_realtime(t));
         TRACE_TASK(t, "RIP\n");
 }
 
+#ifdef CONFIG_FMLP
+
+/* Update the queue position of a task that got it's priority boosted via
+ * priority inheritance. */
+static void update_queue_position(struct task_struct *holder)
+{
+        /* We don't know whether holder is in the ready queue. It should, but
+         * on a budget overrun it may already be in a release queue.  Hence,
+         * calling unlink() is not possible since it assumes that the task is
+         * not in a release queue.  However, we can safely check whether
+         * sem->holder is currently in a queue or scheduled after locking both
+         * the release and the ready queue lock. */
+
+        /* Assumption: caller holds cedf_lock */
+
+        int check_preempt = 0;
+
+        if (tsk_rt(holder)->linked_on != NO_CPU) {
+                TRACE_TASK(holder, "%s: linked  on %d\n",
+                           __FUNCTION__, tsk_rt(holder)->linked_on);
+                /* Holder is scheduled; need to re-order CPUs.
+                 * We can't use heap_decrease() here since
+                 * the cpu_heap is ordered in reverse direction, so
+                 * it is actually an increase. */
+                bheap_delete(cpu_lower_prio, &cedf_cpu_heap,
+                            cedf_cpus[tsk_rt(holder)->linked_on]->hn);
+                bheap_insert(cpu_lower_prio, &cedf_cpu_heap,
+                            cedf_cpus[tsk_rt(holder)->linked_on]->hn);
+        } else {
+                /* holder may be queued: first stop queue changes */
+                spin_lock(&cedf.release_lock);
+                if (is_queued(holder)) {
+                        TRACE_TASK(holder, "%s: is queued\n",
+                                   __FUNCTION__);
+                        /* We need to update the position
+                         * of holder in some heap. Note that this
+                         * may be a release heap. */
+                        check_preempt =
+                                !bheap_decrease(edf_ready_order,
+                                               tsk_rt(holder)->heap_node);
+                } else {
+                        /* Nothing to do: if it is not queued and not linked
+                         * then it is currently being moved by other code
+                         * (e.g., a timer interrupt handler) that will use the
+                         * correct priority when enqueuing the task. */
+                        TRACE_TASK(holder, "%s: is NOT queued => Done.\n",
+                                   __FUNCTION__);
+                }
+                spin_unlock(&cedf.release_lock);
+
+                /* If holder was enqueued in a release heap, then the following
+                 * preemption check is pointless, but we can't easily detect
+                 * that case. If you want to fix this, then consider that
+                 * simply adding a state flag requires O(n) time to update when
+                 * releasing n tasks, which conflicts with the goal to have
+                 * O(log n) merges. */
+                if (check_preempt) {
+                        /* heap_decrease() hit the top level of the heap: make
+                         * sure preemption checks get the right task, not the
+                         * potentially stale cache. */
+                        bheap_uncache_min(edf_ready_order,
+                                         &cedf.ready_queue);
+                        check_for_preemptions();
+                }
+        }
+}
+
+static long cedf_pi_block(struct pi_semaphore *sem,
+                            struct task_struct *new_waiter)
+{
+        /* This callback has to handle the situation where a new waiter is
+         * added to the wait queue of the semaphore.
+         *
+         * We must check if has a higher priority than the currently
+         * highest-priority task, and then potentially reschedule.
+         */
+
+        BUG_ON(!new_waiter);
+
+        if (edf_higher_prio(new_waiter, sem->hp.task)) {
+                TRACE_TASK(new_waiter, " boosts priority via %p\n", sem);
+                /* called with IRQs disabled */
+                spin_lock(&cedf_lock);
+                /* store new highest-priority task */
+                sem->hp.task = new_waiter;
+                if (sem->holder) {
+                        TRACE_TASK(sem->holder,
+                                   " holds %p and will inherit from %s/%d\n",
+                                   sem,
+                                   new_waiter->comm, new_waiter->pid);
+                        /* let holder inherit */
+                        sem->holder->rt_param.inh_task = new_waiter;
+                        update_queue_position(sem->holder);
+                }
+                spin_unlock(&cedf_lock);
+        }
+
+        return 0;
+}
+
+static long cedf_inherit_priority(struct pi_semaphore *sem,
+                                    struct task_struct *new_owner)
+{
+        /* We don't need to acquire the cedf_lock since at the time of this
+         * call new_owner isn't actually scheduled yet (it's still sleeping)
+         * and since the calling function already holds sem->wait.lock, which
+         * prevents concurrent sem->hp.task changes.
+         */
+
+        if (sem->hp.task && sem->hp.task != new_owner) {
+                new_owner->rt_param.inh_task = sem->hp.task;
+                TRACE_TASK(new_owner, "inherited priority from %s/%d\n",
+                           sem->hp.task->comm, sem->hp.task->pid);
+        } else
+                TRACE_TASK(new_owner,
+                           "cannot inherit priority, "
+                           "no higher priority job waits.\n");
+        return 0;
+}
+
+/* This function is called on a semaphore release, and assumes that
+ * the current task is also the semaphore holder.
+ */
+static long cedf_return_priority(struct pi_semaphore *sem)
+{
+        struct task_struct* t = current;
+        int ret = 0;
+
+        /* Find new highest-priority semaphore task
+         * if holder task is the current hp.task.
+         *
+         * Calling function holds sem->wait.lock.
+         */
+        if (t == sem->hp.task)
+                edf_set_hp_task(sem);
+
+        TRACE_CUR("cedf_return_priority for lock %p\n", sem);
+
+        if (t->rt_param.inh_task) {
+                /* interrupts already disabled by PI code */
+                spin_lock(&cedf_lock);
+
+                /* Reset inh_task to NULL. */
+                t->rt_param.inh_task = NULL;
+
+                /* Check if rescheduling is necessary */
+                unlink(t);
+                cedf_job_arrival(t);
+                spin_unlock(&cedf_lock);
+        }
+
+        return ret;
+}
+
+#endif
+
 static long cedf_admit_task(struct task_struct* tsk)
 {
-        return (task_cpu(tsk) >= task_cedf(tsk)->first_cpu &&
-                task_cpu(tsk) <= task_cedf(tsk)->last_cpu) ? 0 : -EINVAL;
+        return 0;
 }
 
+static long cedf_activate_plugin(void)
+{
+        int cpu;
+        cpu_entry_t *entry;
+
+        bheap_init(&cedf_cpu_heap);
+        cedf.release_master = atomic_read(&release_master_cpu);
+
+        for_each_online_cpu(cpu) {
+                entry = &per_cpu(cedf_cpu_entries, cpu);
+                bheap_node_init(&entry->hn, entry);
+                atomic_set(&entry->will_schedule, 0);
+                entry->linked    = NULL;
+                entry->scheduled = NULL;
+                if (cpu != cedf.release_master) {
+                        TRACE("C-EDF: Initializing CPU #%d.\n", cpu);
+                        update_cpu_position(entry);
+                } else {
+                        TRACE("C-EDF: CPU %d is release master.\n", cpu);
+                }
+        }
+        return 0;
+}
 
 /*      Plugin object   */
 static struct sched_plugin cedf_plugin __cacheline_aligned_in_smp = {
@@ -639,89 +794,35 @@ static struct sched_plugin cedf_plugin __cacheline_aligned_in_smp = {
         .schedule               = cedf_schedule,
         .task_wake_up           = cedf_task_wake_up,
         .task_block             = cedf_task_block,
-        .admit_task             = cedf_admit_task
+#ifdef CONFIG_FMLP
+        .fmlp_active            = 1,
+        .pi_block               = cedf_pi_block,
+        .inherit_priority       = cedf_inherit_priority,
+        .return_priority        = cedf_return_priority,
+#endif
+        .admit_task             = cedf_admit_task,
+        .activate_plugin        = cedf_activate_plugin,
 };
 
-static void cedf_domain_init(int first_cpu, int last_cpu)
-{
-        int cpu;
-
-        /* Create new domain for this cluster. */
-        cedf_domain_t *new_cedf_domain = kmalloc(sizeof(*new_cedf_domain),
-                                                     GFP_KERNEL);
-
-        /* Initialize cluster domain. */
-        edf_domain_init(&new_cedf_domain->domain, NULL,
-                        cedf_release_jobs);
-        new_cedf_domain->first_cpu      = first_cpu;
-        new_cedf_domain->last_cpu       = last_cpu;
-        INIT_LIST_HEAD(&new_cedf_domain->cedf_cpu_queue);
-
-        /* Assign all cpus in cluster to point to this domain. */
-        for (cpu = first_cpu; cpu <= last_cpu; cpu++) {
-                remote_cedf(cpu) = new_cedf_domain;
-                cedf_domains_array[cpu] = new_cedf_domain;
-        }
-}
 
 static int __init init_cedf(void)
 {
         int cpu;
         cpu_entry_t *entry;
 
-        /* num_online_cpus() should have been set already
-         * if the number of available cpus is less then the cluster
-         * size (currently 4) then it is pointless trying to use
-         * CEDF, so we disable this plugin
-         */
-        if(num_online_cpus() < cluster_size) {
-                printk(KERN_INFO "Not registering C-EDF plugin: "
-                        "Num Online Cpus (%d) < Min Cluster Size (%d)\n",
-                        num_online_cpus(), cluster_size);
-                do_cleanup = 0;
-                return 0;
-        }
-
-        /*
-         * initialize short_cut for per-cpu cedf state;
-         * there may be a problem here if someone removes a cpu
-         * while we are doing this initialization... and if cpus
-         * are added / removed later... is it a _real_ problem for cedf?
-         */
-        cedf_cpu_entries_array = kmalloc(
-                        sizeof(cpu_entry_t *) * num_online_cpus(),
-                        GFP_KERNEL);
-
-        cedf_domains_array = kmalloc(
-                        sizeof(cedf_domain_t *) * num_online_cpus(),
-                        GFP_KERNEL);
-
+        bheap_init(&cedf_cpu_heap);
         /* initialize CPU state */
-        for (cpu = 0; cpu < num_online_cpus(); cpu++)  {
+        for (cpu = 0; cpu < NR_CPUS; cpu++)  {
                 entry = &per_cpu(cedf_cpu_entries, cpu);
-                cedf_cpu_entries_array[cpu] = entry;
+                cedf_cpus[cpu] = entry;
                 atomic_set(&entry->will_schedule, 0);
-                entry->linked    = NULL;
-                entry->scheduled = NULL;
                 entry->cpu       = cpu;
-                INIT_LIST_HEAD(&entry->list);
+                entry->hn        = &cedf_heap_node[cpu];
+                bheap_node_init(&entry->hn, entry);
         }
-
-        /* initialize all cluster domains */
-        for (cpu = 0; cpu < num_online_cpus(); cpu += cluster_size)
-                cedf_domain_init(cpu, cpu+cluster_size-1);
-
+        edf_domain_init(&cedf, NULL, cedf_release_jobs);
         return register_sched_plugin(&cedf_plugin);
 }
 
-static void clean_cedf(void)
-{
-        if(do_cleanup) {
-                kfree(cedf_cpu_entries_array);
-                kfree(cedf_domains_array);
-        }
-}
 
 module_init(init_cedf);
-module_exit(clean_cedf);
-