simplify P-EDF

- use edf_higher_prio
- use is_released macro
- store scheduled task in per CPU state

1 files changed, 20 insertions, 34 deletions

diff --git a/kernel/sched_part_edf.c b/kernel/sched_part_edf.c
index cdc75165b2..46a999e122 100644
--- a/kernel/sched_part_edf.c
+++ b/kernel/sched_part_edf.c
@@ -15,11 +15,10 @@
 
 
 typedef struct {
-        edf_domain_t domain;
-        int          cpu;
-        int          executes_realtime;
-        jiffie_t     cur_deadline;      
-        spinlock_t   lock;
+        edf_domain_t            domain;
+        int                     cpu;
+        struct task_struct*     scheduled; /* only RT tasks */
+        spinlock_t              lock;
 } part_edf_domain_t;
 
 
@@ -28,10 +27,9 @@ static void part_edf_domain_init(part_edf_domain_t* pedf,
                                  int cpu)
 {
         edf_domain_init(&pedf->domain, check);
-        pedf->cur_deadline      = 0;
         pedf->cpu               = cpu;
         pedf->lock              = SPIN_LOCK_UNLOCKED;
-        pedf->executes_realtime = 0;
+        pedf->scheduled         = NULL;
 }
 
 DEFINE_PER_CPU(part_edf_domain_t, part_edf_domains);
@@ -39,7 +37,6 @@ DEFINE_PER_CPU(part_edf_domain_t, part_edf_domains);
 /* This check is trivial in partioned systems as we only have to consider
  * the CPU of the partition.
  *
- * TODO: implement will_schedule test.
  */
 static int part_edf_check_resched(edf_domain_t *edf) 
 {
@@ -47,17 +44,16 @@ static int part_edf_check_resched(edf_domain_t *edf)
         int ret = 0;
 
         spin_lock(&pedf->lock);
-        if (!list_empty(&edf->ready_queue)) {
-                if (!pedf->executes_realtime ||
-                    time_before(
-                            next_ready(edf)->rt_param.times.deadline,
-                            pedf->cur_deadline)
-                        ) {
-                        if (pedf->cpu == smp_processor_id())
-                                set_tsk_need_resched(current);
-                        else
-                                smp_send_reschedule(pedf->cpu);
-                }
+       
+        /* because this is a callback from edf_domain_t we already hold
+         * the necessary lock for the ready queue
+         */
+        if (preemption_needed(edf, pedf->scheduled)) {
+                if (pedf->cpu == smp_processor_id())
+                        set_tsk_need_resched(current);
+                else
+                        smp_send_reschedule(pedf->cpu);
+                ret = 1;
         }
         spin_unlock(&pedf->lock);
         return ret;
@@ -108,8 +104,6 @@ static int part_edf_schedule(struct task_struct * prev,
                              runqueue_t * rq)
 {
         int                     need_deactivate = 1;
-        int                     rt;
-        jiffie_t                deadline;
         unsigned long           flags;
         part_edf_domain_t*      pedf = &__get_cpu_var(part_edf_domains);
         edf_domain_t*           edf  = &pedf->domain; 
@@ -128,8 +122,6 @@ static int part_edf_schedule(struct task_struct * prev,
                          */
                         TRACE("prev will be next, already released\n");
                         *next = prev;
-                        rt = 1;
-                        deadline = prev->rt_param.times.deadline;
                         need_deactivate = 0;
                 } else {
                         /* either not yet released, preempted, or non-rt */
@@ -138,19 +130,14 @@ static int part_edf_schedule(struct task_struct * prev,
                                 /* stick the task into the runqueue */
                                 __activate_task(*next, rq);
                                 set_task_cpu(*next, smp_processor_id());
-                                rt = 1;
-                                deadline = (*next)->rt_param.times.deadline;
-                        } 
-                        else
-                                rt = deadline = 0;                      
+                        }
                 }
                 spin_lock(&pedf->lock);
-                pedf->executes_realtime = rt;
-                pedf->cur_deadline      = deadline;
+                pedf->scheduled = *next;
                 spin_unlock(&pedf->lock);
-                if (rt) {
+                if (*next)
                         set_rt_flags(*next, RT_F_RUNNING);
-                }
+                
                 write_unlock_irqrestore(&edf->ready_lock, flags);
         } 
 
@@ -177,8 +164,7 @@ static void part_edf_finish_switch(struct task_struct *prev)
                  * the release and
                  * deadline. We just must check if has been released.
                  */
-                if (time_before_eq(prev->rt_param.times.release, jiffies) 
-                    && get_rt_mode() == MODE_RT_RUN) {
+                if (is_released(prev) && get_rt_mode() == MODE_RT_RUN) {
                         /* already released */
                         add_ready(edf, prev);
                         TRACE("%d goes straight to ready queue\n", prev->pid);