Introduce rt_domain_t.

9 files changed, 327 insertions, 291 deletions

diff --git a/include/linux/edf_common.h b/include/linux/edf_common.h
index 6b0eb2ff17..f940308fdd 100644
--- a/include/linux/edf_common.h
+++ b/include/linux/edf_common.h
@@ -9,68 +9,27 @@
 #ifndef __UNC_EDF_COMMON_H__
 #define __UNC_EDF_COMMON_H__
 
-struct _edf_domain;
+#include <linux/rt_domain.h>
 
-typedef int (*edf_check_resched_needed_t)(struct _edf_domain *edf);
-typedef struct _edf_domain {
-        /* runnable rt tasks are in here */
-        rwlock_t                        ready_lock;
-        struct list_head                ready_queue; 
 
-        /* real-time tasks waiting for release are in here */
-        spinlock_t                      release_lock;
-        struct list_head                release_queue;
-
-        /* how do we check if we need to kick another CPU? */
-        edf_check_resched_needed_t      check_resched;
-} edf_domain_t;
-
-#define next_ready(edf) \
-        (list_entry((edf)->ready_queue.next, struct task_struct, rt_list))
-
-void edf_domain_init(edf_domain_t *edf, edf_check_resched_needed_t f);
+void edf_domain_init(rt_domain_t* rt, check_resched_needed_t resched);
 
 int edf_higher_prio(struct task_struct* first, 
                     struct task_struct* second);
 
-void __add_ready(edf_domain_t* edf, struct task_struct *new);
-void __add_release(edf_domain_t* edf, struct task_struct *task);
-
-struct task_struct* __take_ready(edf_domain_t* edf);
-struct task_struct* __peek_ready(edf_domain_t* edf);
+int edf_ready_order(struct list_head* a, struct list_head* b);
 
+void edf_release_at(struct task_struct *t, jiffie_t start);
+#define edf_release_now(t) edf_release_at(t, jiffies)
 
-void try_release_pending(edf_domain_t* edf);
-void __release_pending(edf_domain_t* edf);
-void __prepare_new_release(struct task_struct *t, jiffie_t start);
-#define prepare_new_release(t) __prepare_new_release(t, jiffies)
-void prepare_for_next_period(struct task_struct *t);
-void prepare_new_releases(edf_domain_t *edf, jiffie_t start);
-void __prepare_new_releases(edf_domain_t *edf, jiffie_t start);
-int preemption_needed(edf_domain_t* edf, struct task_struct *t);
+int  edf_preemption_needed(rt_domain_t* rt, struct task_struct *t);
 long edf_sleep_next_period(void);
 
+void edf_prepare_for_next_period(struct task_struct *t);
+
 #define job_completed(t) (!is_be(t) && \
         (t)->rt_param.times.exec_time == (t)->rt_param.basic_params.exec_cost)
 
-static inline void add_ready(edf_domain_t* edf, struct task_struct *new)
-{
-        unsigned long flags;    
-        /* first we need the write lock for edf_ready_queue */  
-        write_lock_irqsave(&edf->ready_lock, flags);
-        __add_ready(edf, new);
-        write_unlock_irqrestore(&edf->ready_lock, flags);
-}
-
-static inline void add_release(edf_domain_t* edf, struct task_struct *task)
-{
-        unsigned long flags;    
-        /* first we need the write lock for edf_ready_queue */  
-        spin_lock_irqsave(&edf->release_lock, flags);
-        __add_release(edf, task);
-        spin_unlock_irqrestore(&edf->release_lock, flags);
-}
-
 int edf_set_hp_task(struct pi_semaphore *sem);
 int edf_set_hp_cpu_task(struct pi_semaphore *sem, int cpu);
 
diff --git a/include/linux/list.h b/include/linux/list.h
index e7d758c5fa..319c5eda13 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -903,7 +903,7 @@ typedef int (*list_cmp_t)(struct list_head*, struct list_head*);
 
 static inline unsigned int list_insert(struct list_head* new,
                                        struct list_head* head,
-                                       list_cmp_t is_less)
+                                       list_cmp_t order_before)
 {
         struct list_head *pos;
         unsigned int passed = 0;
@@ -912,7 +912,7 @@ static inline unsigned int list_insert(struct list_head* new,
 
         /* find a spot where the new entry is less than the next */
         list_for_each(pos, head) {              
-                if (unlikely(is_less(new, pos))) {
+                if (unlikely(order_before(new, pos))) {
                         /* pos is not less than new, thus insert here */
                         __list_add(new, pos->prev, pos);
                         goto out;
diff --git a/include/linux/rt_domain.h b/include/linux/rt_domain.h
new file mode 100644
index 0000000000..7157a04ac2
--- /dev/null
+++ b/include/linux/rt_domain.h
@@ -0,0 +1,69 @@
+/* CLEANUP: Add comments and make it less messy.
+ *
+ */
+
+#ifndef __UNC_RT_DOMAIN_H__
+#define __UNC_RT_DOMAIN_H__
+
+struct _rt_domain;
+
+typedef int (*check_resched_needed_t)(struct _rt_domain *rt);
+typedef void (*release_at_t)(struct task_struct *t, jiffie_t start);
+
+typedef struct _rt_domain {
+        /* runnable rt tasks are in here */
+        rwlock_t                        ready_lock;
+        struct list_head                ready_queue; 
+
+        /* real-time tasks waiting for release are in here */
+        spinlock_t                      release_lock;
+        struct list_head                release_queue;
+
+        /* how do we check if we need to kick another CPU? */
+        check_resched_needed_t          check_resched;
+
+        /* how are tasks ordered in the ready queue? */
+        list_cmp_t                      order;
+} rt_domain_t;
+
+#define next_ready(rt) \
+        (list_entry((rt)->ready_queue.next, struct task_struct, rt_list))
+
+#define ready_jobs_pending(rt) \
+        (!list_empty(&(rt)->ready_queue))
+
+void rt_domain_init(rt_domain_t *rt, check_resched_needed_t f, 
+                    list_cmp_t order);
+
+void __add_ready(rt_domain_t* rt, struct task_struct *new);
+void __add_release(rt_domain_t* rt, struct task_struct *task);
+
+struct task_struct* __take_ready(rt_domain_t* rt);
+struct task_struct* __peek_ready(rt_domain_t* rt);
+
+void try_release_pending(rt_domain_t* rt);
+void __release_pending(rt_domain_t* rt);
+
+void rerelease_all(rt_domain_t *rt, release_at_t release);
+void __rerelease_all(rt_domain_t *rt, release_at_t release);
+
+static inline void add_ready(rt_domain_t* rt, struct task_struct *new)
+{
+        unsigned long flags;    
+        /* first we need the write lock for rt_ready_queue */   
+        write_lock_irqsave(&rt->ready_lock, flags);
+        __add_ready(rt, new);
+        write_unlock_irqrestore(&rt->ready_lock, flags);
+}
+
+static inline void add_release(rt_domain_t* rt, struct task_struct *task)
+{
+        unsigned long flags;    
+        /* first we need the write lock for rt_ready_queue */   
+        spin_lock_irqsave(&rt->release_lock, flags);
+        __add_release(rt, task);
+        spin_unlock_irqrestore(&rt->release_lock, flags);
+}
+
+
+#endif 
diff --git a/kernel/Makefile b/kernel/Makefile
index ce9dfa08b9..1b6957b160 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -13,7 +13,7 @@ obj-y     = sched.o fork.o exec_domain.o panic.o printk.o profile.o \
             edf_common.o fifo_common.o pfair_common.o\
             sched_global_edf.o sched_part_edf.o sched_edf_hsb.o sched_pfair.o \
             sched_gsn_edf.o sched_psn_edf.o litmus_sem.o \
-            trace.o ft_event.o
+            trace.o ft_event.o rt_domain.o
 
 obj-$(CONFIG_STACKTRACE) += stacktrace.o
 obj-y += time/
diff --git a/kernel/edf_common.c b/kernel/edf_common.c
index fa83450fe0..065e798a8a 100644
--- a/kernel/edf_common.c
+++ b/kernel/edf_common.c
@@ -12,26 +12,8 @@
 #include <linux/sched_plugin.h>
 #include <linux/sched_trace.h>
 
-#include <linux/edf_common.h>
-
-
-static int dummy_resched(edf_domain_t *edf) 
-{
-        return 0;
-}
-
-void edf_domain_init(edf_domain_t *edf, edf_check_resched_needed_t f) 
-{
-        BUG_ON(!edf);
-        if (!f)
-                f = dummy_resched;
-        INIT_LIST_HEAD(&edf->ready_queue);
-        INIT_LIST_HEAD(&edf->release_queue);
-        edf->ready_lock         = RW_LOCK_UNLOCKED;
-        edf->release_lock       = SPIN_LOCK_UNLOCKED;
-        edf->check_resched      = f;
-}
 
+#include <linux/edf_common.h>
 
 /* edf_higher_prio -  returns true if first has a higher EDF priority
  *                    than second. Deadline ties are broken by PID.
@@ -78,131 +60,27 @@ int edf_higher_prio(struct task_struct* first,
                  !second->rt_param.inh_task)));
 }
 
-
-/* add_ready - add a real-time task to the edf ready queue. It must be runnable.
- * @new:      the newly released task
- */
-void __add_ready(edf_domain_t* edf, struct task_struct *new) 
-{       
-        struct list_head *pos;
-        struct task_struct *queued;
-        unsigned int passed = 0;
-
-        BUG_ON(!new);
-        TRACE("edf: adding %s/%d (%u, %u) to ready queue\n", 
-              new->comm, new->pid, get_exec_cost(new), get_rt_period(new));
-
-        /* find a spot where our deadline is earlier than the next */
-        list_for_each(pos, &edf->ready_queue) {         
-                queued = list_entry(pos, struct task_struct, rt_list);
-                if (unlikely(edf_higher_prio(new, queued))) {
-                        /* the task at pos has a later deadline */
-                        /* insert the new task in front of it */
-                        __list_add(&new->rt_list, pos->prev, pos);
-                        goto out;
-                }
-                passed++;
-        }
-        /* if we get to this point either the list is empty or new has the
-         * lowest priority. Let's add it to the end. */
-        list_add_tail(&new->rt_list, &edf->ready_queue);
- out:
-        if (!passed)
-                edf->check_resched(edf);
-}
-
-struct task_struct* __take_ready(edf_domain_t* edf) 
-{
-        struct task_struct *t = __peek_ready(edf);
-
-        /* kick it out of the ready list */
-        if (t)
-                list_del(&t->rt_list);  
-        return t;
-}
-
-
-struct task_struct* __peek_ready(edf_domain_t* edf)
-{
-        struct task_struct *t = NULL;
-        /* either not yet released, preempted, or non-rt */
-        if (!list_empty(&edf->ready_queue))
-                /* take next rt task */
-                t = list_entry(edf->ready_queue.next, struct task_struct, 
-                               rt_list);
-        return t;
-}
-
-
-/* add_release - add a real-time task to the edf release queue.
- * @task:        the sleeping task
- */
-void __add_release(edf_domain_t* edf, struct task_struct *task) 
-{
-        struct list_head *pos;
-        struct task_struct *queued;
-
-        BUG_ON(!task);
-        /* first we need the lock for edf_release_queue */      
-        TRACE("edf: adding %s/%d (%u, %u) to release queue\n", 
-              task->comm, task->pid, get_exec_cost(task), get_rt_period(task));
-
-        /* find a spot where our deadline is earlier than the next */
-        list_for_each_prev(pos, &edf->release_queue) {          
-                queued = list_entry(pos, struct task_struct, rt_list);
-                if ((unlikely(earlier_release(queued, task)))) {
-                        /* the task at pos has an earlier release */
-                        /* insert the new task in behind it */
-                        __list_add(&task->rt_list, pos, pos->next);
-                        return;
-                }
-        }
-        /* if we get to this point either the list is empty or task has the
-         * earliest release. Let's add it to the front. */
-        list_add(&task->rt_list, &edf->release_queue);
-}
-
-void __release_pending(edf_domain_t* edf)
+int edf_ready_order(struct list_head* a, struct list_head* b)
 {
-        struct list_head *pos, *save;
-        struct task_struct   *queued;
-        list_for_each_safe(pos, save, &edf->release_queue) {
-                queued = list_entry(pos, struct task_struct, rt_list);
-                if (likely(is_released(queued))) {
-                        /* this one is ready to go*/
-                        list_del(pos);
-                        set_rt_flags(queued, RT_F_RUNNING);
-                        
-                        sched_trace_job_release(queued);
-                        
-                        /* now it can be picked up */
-                        barrier();
-                        add_ready(edf, queued);
-                } 
-                else
-                        /* the release queue is ordered */
-                        break;                  
-        }
+        return edf_higher_prio(
+                list_entry(a, struct task_struct, rt_list),
+                list_entry(b, struct task_struct, rt_list));
 }
 
-void try_release_pending(edf_domain_t* edf) 
+void edf_release_at(struct task_struct *t, jiffie_t start) 
 {
-        unsigned long flags;
-
-        if (spin_trylock_irqsave(&edf->release_lock, flags)) {
-                __release_pending(edf);
-                spin_unlock_irqrestore(&edf->release_lock, flags);
-        }
-}                   
-
-void __prepare_new_release(struct task_struct *t, jiffie_t start) {
         t->rt_param.times.deadline = start;
         t->rt_param.stats.nontardy_jobs_ctr = 0xf0000000;
-        prepare_for_next_period(t);
+        edf_prepare_for_next_period(t);
         set_rt_flags(t, RT_F_RUNNING);  
 }
 
-void prepare_for_next_period(struct task_struct *t)
+void edf_domain_init(rt_domain_t* rt, check_resched_needed_t resched)
+{
+        rt_domain_init(rt, resched, edf_ready_order);
+}
+
+void edf_prepare_for_next_period(struct task_struct *t)
 {
         BUG_ON(!t);     
         /* update tardy job ctr */
@@ -220,56 +98,14 @@ void prepare_for_next_period(struct task_struct *t)
         t->first_time_slice = 0; 
 }
 
-void prepare_new_releases(edf_domain_t *edf, jiffie_t start) 
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&edf->release_lock, flags);
-        write_lock(&edf->ready_lock);
-
-        __prepare_new_releases(edf, start);
-        
-        write_unlock(&edf->ready_lock);
-        spin_unlock_irqrestore(&edf->release_lock, flags);
-}
-
-void __prepare_new_releases(edf_domain_t *edf, jiffie_t start) 
-{
-
-        struct list_head tmp_list;
-        struct list_head *pos, *n;
-        struct task_struct *t;
-        
-        INIT_LIST_HEAD(&tmp_list);
-
-        while (!list_empty(&edf->release_queue)) {
-                pos = edf->release_queue.next;
-                list_del(pos);
-                list_add(pos, &tmp_list);              
-        }
-        while (!list_empty(&edf->ready_queue)) {
-                pos = edf->ready_queue.next;
-                list_del(pos);
-                list_add(pos, &tmp_list);
-        }
-
-        list_for_each_safe(pos, n, &tmp_list) {
-                t = list_entry(pos, struct task_struct, rt_list);
-                list_del(pos);
-                __prepare_new_release(t, start);
-                __add_release(edf, t);
-        }
-
-}
-
 /* need_to_preempt - check whether the task t needs to be preempted
  *                   call only with irqs disabled and with  ready_lock acquired
  */
-int preemption_needed(edf_domain_t* edf, struct task_struct *t)
+int edf_preemption_needed(rt_domain_t* rt, struct task_struct *t)
 {
         /* we need the read lock for edf_ready_queue */ 
         /* no need to preempt if there is nothing pending */
-        if (list_empty(&edf->ready_queue))
+        if (!ready_jobs_pending(rt))
                 return 0;
         /* we need to reschedule if t doesn't exist */
         if (!t)
@@ -277,7 +113,7 @@ int preemption_needed(edf_domain_t* edf, struct task_struct *t)
         /* don't preempt if t is non-preemptable */
         if (!is_np(t)) 
                 /* make sure to get non-rt stuff out of the way */
-                return !is_realtime(t) || edf_higher_prio(next_ready(edf), t);
+                return !is_realtime(t) || edf_higher_prio(next_ready(rt), t);
         return 0;
 }
 
diff --git a/kernel/rt_domain.c b/kernel/rt_domain.c
new file mode 100644
index 0000000000..52752d98c8
--- /dev/null
+++ b/kernel/rt_domain.c
@@ -0,0 +1,170 @@
+/*
+ * kernel/rt_domain.c
+ *
+ * LITMUS real-time infrastructure. This file contains the 
+ * functions that manipulate RT domains. RT domains are an abstraction
+ * of a ready queue and a release queue.
+ */
+
+#include <linux/percpu.h>
+#include <linux/sched.h>
+#include <linux/list.h>
+
+#include <linux/litmus.h>
+#include <linux/sched_plugin.h>
+#include <linux/sched_trace.h>
+
+#include <linux/rt_domain.h>
+
+
+static int dummy_resched(rt_domain_t *rt) 
+{
+        return 0;
+}
+
+static int dummy_order(struct list_head* a, struct list_head* b)
+{
+        return 0;
+}
+
+int release_order(struct list_head* a, struct list_head* b)
+{
+        return earlier_release(
+                list_entry(a, struct task_struct, rt_list),
+                list_entry(b, struct task_struct, rt_list));
+}
+
+
+void rt_domain_init(rt_domain_t *rt, 
+                    check_resched_needed_t f,
+                    list_cmp_t order) 
+{
+        BUG_ON(!rt);
+        if (!f)
+                f = dummy_resched;
+        if (!order)
+                order = dummy_order;
+        INIT_LIST_HEAD(&rt->ready_queue);
+        INIT_LIST_HEAD(&rt->release_queue);
+        rt->ready_lock          = RW_LOCK_UNLOCKED;
+        rt->release_lock        = SPIN_LOCK_UNLOCKED;
+        rt->check_resched       = f;
+        rt->order               = order;
+}
+
+/* add_ready - add a real-time task to the rt ready queue. It must be runnable.
+ * @new:      the newly released task
+ */
+void __add_ready(rt_domain_t* rt, struct task_struct *new) 
+{       
+        TRACE("rt: adding %s/%d (%u, %u) to ready queue\n", 
+              new->comm, new->pid, get_exec_cost(new), get_rt_period(new));
+
+        if (!list_insert(&new->rt_list, &rt->ready_queue, rt->order))
+                rt->check_resched(rt);
+}
+
+struct task_struct* __take_ready(rt_domain_t* rt) 
+{
+        struct task_struct *t = __peek_ready(rt);
+
+        /* kick it out of the ready list */
+        if (t)
+                list_del(&t->rt_list);  
+        return t;
+}
+
+struct task_struct* __peek_ready(rt_domain_t* rt)
+{
+        if (!list_empty(&rt->ready_queue))
+                return next_ready(rt);
+        else
+                return NULL;
+}
+
+/* add_release - add a real-time task to the rt release queue.
+ * @task:        the sleeping task
+ */
+void __add_release(rt_domain_t* rt, struct task_struct *task) 
+{
+        list_insert(&task->rt_list, &rt->release_queue, release_order);
+}
+
+void __release_pending(rt_domain_t* rt)
+{
+        struct list_head *pos, *save;
+        struct task_struct   *queued;
+        list_for_each_safe(pos, save, &rt->release_queue) {
+                queued = list_entry(pos, struct task_struct, rt_list);
+                if (likely(is_released(queued))) {
+                        /* this one is ready to go*/
+                        list_del(pos);
+                        set_rt_flags(queued, RT_F_RUNNING);
+                        
+                        sched_trace_job_release(queued);
+                        
+                        /* now it can be picked up */
+                        barrier();
+                        add_ready(rt, queued);
+                } 
+                else
+                        /* the release queue is ordered */
+                        break;                  
+        }
+}
+
+void try_release_pending(rt_domain_t* rt) 
+{
+        unsigned long flags;
+
+        if (spin_trylock_irqsave(&rt->release_lock, flags)) {
+                __release_pending(rt);
+                spin_unlock_irqrestore(&rt->release_lock, flags);
+        }
+}                   
+
+void rerelease_all(rt_domain_t *rt,  
+                   release_at_t release) 
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&rt->release_lock, flags);
+        write_lock(&rt->ready_lock);
+
+        __prepare_new_releases(rt, start, release);
+        
+        write_unlock(&rt->ready_lock);
+        spin_unlock_irqrestore(&rt->release_lock, flags);
+}
+
+void __rerelease_all(rt_domain_t *rt,
+                     release_at_t release) 
+{
+        jiffie_t start = jiffies + 10;
+        struct list_head tmp_list;
+        struct list_head *pos, *n;
+        struct task_struct *t;
+        
+        INIT_LIST_HEAD(&tmp_list);
+
+        while (!list_empty(&rt->release_queue)) {
+                pos = rt->release_queue.next;
+                list_del(pos);
+                list_add(pos, &tmp_list);              
+        }
+        while (!list_empty(&rt->ready_queue)) {
+                pos = rt->ready_queue.next;
+                list_del(pos);
+                list_add(pos, &tmp_list);
+        }
+
+        list_for_each_safe(pos, n, &tmp_list) {
+                t = list_entry(pos, struct task_struct, rt_list);
+                list_del(pos);
+                release(t, start);
+                __add_release(rt, t);
+        }
+
+}
+
+
diff --git a/kernel/sched_edf_hsb.c b/kernel/sched_edf_hsb.c
index d190426ff8..b8ac1ab0f8 100644
--- a/kernel/sched_edf_hsb.c
+++ b/kernel/sched_edf_hsb.c
@@ -211,7 +211,7 @@ capacity_t* __take_capacity(capacity_queue_t* queue, jiffie_t deadline, int dead
  * HRT servers are strictly periodic and retain their budget.
  */
 typedef struct {
-        edf_domain_t            domain;
+        rt_domain_t             domain;
 
         unsigned int            period;
         unsigned int            wcet;
@@ -302,7 +302,7 @@ static inline int hrt_client_eligible(hrt_server_t *srv)
 }
 
 static void hsb_cpu_state_init(cpu_state_t* cpu_state, 
-                               edf_check_resched_needed_t check,
+                               check_resched_needed_t check,
                                int cpu)
 {
         edf_domain_init(&cpu_state->hrt.domain, check);
@@ -333,7 +333,7 @@ static void hsb_cpu_state_init(cpu_state_t* cpu_state,
         (a)->release, (b)->release))
 
 
-static void be_add_ready(edf_domain_t* edf, be_server_t *new) 
+static void be_add_ready(rt_domain_t* edf, be_server_t *new) 
 {
         unsigned long flags;
         struct list_head *pos;
@@ -341,7 +341,7 @@ static void be_add_ready(edf_domain_t* edf, be_server_t *new)
         unsigned int passed = 0;
 
         BUG_ON(!new);
-        /* first we need the write lock for edf_ready_queue */  
+        /* first we need the write lock for rt_ready_queue */   
         write_lock_irqsave(&edf->ready_lock, flags);
         /* find a spot where our deadline is earlier than the next */
         list_for_each(pos, &edf->ready_queue) {         
@@ -361,7 +361,7 @@ static void be_add_ready(edf_domain_t* edf, be_server_t *new)
         write_unlock_irqrestore(&edf->ready_lock, flags);
 }
 
-static be_server_t* be_take_ready(edf_domain_t* edf) 
+static be_server_t* be_take_ready(rt_domain_t* edf) 
 {
         be_server_t *t = NULL;
 
@@ -373,7 +373,7 @@ static be_server_t* be_take_ready(edf_domain_t* edf)
         return t;
 }
 
-/*static be_server_t* get_be_server(edf_domain_t* edf) 
+/*static be_server_t* get_be_server(rt_domain_t* edf) 
 {
         be_server_t *t = NULL;
 
@@ -392,7 +392,7 @@ static be_server_t* be_take_ready(edf_domain_t* edf)
         return t;       
 }*/
 
-static void be_add_release(edf_domain_t* edf, be_server_t *srv) 
+static void be_add_release(rt_domain_t* edf, be_server_t *srv) 
 {
         unsigned long flags;
         struct list_head *pos;
@@ -414,7 +414,7 @@ static void be_add_release(edf_domain_t* edf, be_server_t *srv)
         spin_unlock_irqrestore(&edf->release_lock, flags);
 }
 
-static void be_try_release_pending(edf_domain_t* edf) 
+static void be_try_release_pending(rt_domain_t* edf) 
 {
         unsigned long flags;
         struct list_head *pos, *save;
@@ -445,7 +445,7 @@ static void be_prepare_new_release(be_server_t *t, jiffie_t start) {
         t->budget    = t->wcet;
 }
 
-static void be_prepare_new_releases(edf_domain_t *edf, jiffie_t start) 
+static void be_prepare_new_releases(rt_domain_t *edf, jiffie_t start) 
 {
         unsigned long flags;
         struct list_head tmp_list;
@@ -499,9 +499,9 @@ static void be_prepare_for_next_period(be_server_t *t)
 /* need_to_preempt - check whether the task t needs to be preempted by a
  *                   best-effort server.
  */
-static inline int be_preemption_needed(edf_domain_t* edf, cpu_state_t* state)
+static inline int be_preemption_needed(rt_domain_t* edf, cpu_state_t* state)
 {       
-        /* we need the read lock for edf_ready_queue */ 
+        /* we need the read lock for rt_ready_queue */  
         if (!list_empty(&edf->ready_queue))
         {
 
@@ -520,7 +520,7 @@ static inline int be_preemption_needed(edf_domain_t* edf, cpu_state_t* state)
         return 0;
 }
 
-static void be_enqueue(edf_domain_t* edf, be_server_t* srv)
+static void be_enqueue(rt_domain_t* edf, be_server_t* srv)
 {
         int new_release = 0;
         if (!srv->budget) {
@@ -539,7 +539,7 @@ static void be_enqueue(edf_domain_t* edf, be_server_t* srv)
                 be_add_release(edf, srv);
 }
 
-static void be_preempt(edf_domain_t *be, cpu_state_t *state) 
+static void be_preempt(rt_domain_t *be, cpu_state_t *state) 
 {
         be_server_t *srv;
         
@@ -565,12 +565,12 @@ static LIST_HEAD(hsb_cpu_queue);
 
 
 /* the global soft real-time domain */
-static edf_domain_t srt;
+static rt_domain_t srt;
 /* the global best-effort server domain
  * belongs conceptually to the srt domain, but has 
  * be_server_t* queued instead of tast_t*
  */
-static edf_domain_t be;
+static rt_domain_t be;
 
 static fifo_domain_t hsb_fifo;
 
@@ -653,7 +653,7 @@ static void adjust_cpu_queue(task_class_t class, jiffie_t deadline,
 /* hrt_check_resched - check whether the HRT server on given CPU needs to 
  *                     preempt the running task.
  */
-static int hrt_check_resched(edf_domain_t *edf) 
+static int hrt_check_resched(rt_domain_t *edf) 
 {
         hrt_server_t *srv  = container_of(edf, hrt_server_t, domain);
         cpu_state_t *state = container_of(srv, cpu_state_t, hrt);
@@ -687,7 +687,7 @@ static int hrt_check_resched(edf_domain_t *edf)
  *
  * Caller must hold edf->ready_lock!
  */
-static int srt_check_resched(edf_domain_t *edf) 
+static int srt_check_resched(rt_domain_t *edf) 
 {
         cpu_state_t *last;
         int ret = 0;
@@ -722,7 +722,7 @@ static int srt_check_resched(edf_domain_t *edf)
  *
  * Caller must hold edf->ready_lock!
  */
-static int be_check_resched(edf_domain_t *edf) 
+static int be_check_resched(rt_domain_t *edf) 
 {
         cpu_state_t *last;
         int soft, bg;
@@ -828,9 +828,9 @@ int fifo_check_resched(void)
 
 
 
-static inline int hsb_preemption_needed(edf_domain_t* edf, cpu_state_t* state)
+static inline int hsb_preemption_needed(rt_domain_t* edf, cpu_state_t* state)
 {
-        /* we need the read lock for edf_ready_queue */ 
+        /* we need the read lock for rt_ready_queue */  
         if (!list_empty(&edf->ready_queue))
         {
                 if (state->exec_class == RT_CLASS_SOFT) {
@@ -848,7 +848,7 @@ static inline int hsb_preemption_needed(edf_domain_t* edf, cpu_state_t* state)
                                         
 static inline int cap_preemption_needed(capacity_queue_t* q, cpu_state_t* state)
 {
-        /* we need the read lock for edf_ready_queue */ 
+        /* we need the read lock for rt_ready_queue */  
         if (!list_empty(&q->queue))
         {
                 if (state->exec_class == RT_CLASS_SOFT) {
@@ -938,8 +938,9 @@ static reschedule_check_t hsb_scheduler_tick(void)
                         case RT_CLASS_HARD:
                                 read_lock_irqsave(&state->hrt.domain.ready_lock,
                                                   flags);
-                                resched = preemption_needed(&state->hrt.domain,
-                                                            t);
+                                resched = edf_preemption_needed(
+                                                  &state->hrt.domain,
+                                                  t);
                                 read_unlock_irqrestore(
                                         &state->hrt.domain.ready_lock, flags);
                                 break;
@@ -1017,7 +1018,7 @@ static int schedule_hrt(struct task_struct * prev,
         }       
 
         if (is_hrt(prev) && is_released(prev) && is_running(prev)
-            && !preemption_needed(&state->hrt.domain, prev)) {
+            && !edf_preemption_needed(&state->hrt.domain, prev)) {
                 /* This really should only happen if the task has 
                  * 100% utilization or when we got a bogus/delayed 
                  * resched IPI.
@@ -1046,7 +1047,7 @@ static int schedule_hrt(struct task_struct * prev,
 
 
 static struct task_struct* find_min_slack_task(struct task_struct *prev, 
-                                               edf_domain_t* edf) 
+                                               rt_domain_t* edf) 
 {
         struct list_head *pos;
         struct task_struct* tsk = NULL;
@@ -1064,7 +1065,7 @@ static struct task_struct* find_min_slack_task(struct task_struct *prev,
 }
 
 static struct task_struct* null_heuristic(struct task_struct *prev, 
-                                          edf_domain_t* edf, 
+                                          rt_domain_t* edf, 
                                           fifo_domain_t* fifo) 
 {
         if (fifo_jobs_pending( fifo))
@@ -1076,7 +1077,7 @@ static struct task_struct* null_heuristic(struct task_struct *prev,
                 return NULL;
 }
 
-/*static struct task_struct* history_heuristic(struct task_struct *prev, edf_domain_t* edf)
+/*static struct task_struct* history_heuristic(struct task_struct *prev, rt_domain_t* edf)
 {
         struct list_head *pos;
         struct task_struct* tsk = NULL;
@@ -1099,7 +1100,7 @@ static struct task_struct* null_heuristic(struct task_struct *prev,
 }
 */
 /* TODO: write slack heuristic.*/
-/*static struct task_struct* slack_heuristic(struct task_struct *prev, edf_domain_t* edf)
+/*static struct task_struct* slack_heuristic(struct task_struct *prev, rt_domain_t* edf)
 {
         struct list_head *pos;
         struct task_struct* tsk = NULL;
@@ -1182,7 +1183,7 @@ static int schedule_capacity(struct task_struct *prev,
 #define BE  2
 #define CAP 3
 
-static inline int what_first(edf_domain_t *be, edf_domain_t *srt, capacity_queue_t* q)
+static inline int what_first(rt_domain_t *be, rt_domain_t *srt, capacity_queue_t* q)
 {
         jiffie_t sdl = 0, bdl= 0, cdl = 0, cur;
         int _srt = !list_empty(&srt->ready_queue);
@@ -1370,7 +1371,7 @@ static int hsb_schedule(struct task_struct * prev, struct task_struct ** next,
                 TRACE("preparing %d for next period\n", prev->pid);
                 release_capacity(&cap_queue, prev->time_slice, 
                                  prev->rt_param.times.deadline, prev);
-                prepare_for_next_period(prev);          
+                edf_prepare_for_next_period(prev);              
         }
         
         if (get_rt_mode() == MODE_RT_RUN) {
@@ -1490,7 +1491,7 @@ static long hsb_prepare_task(struct task_struct * t)
                         /* The action is already on. 
                          * Prepare immediate release
                          */
-                        prepare_new_release(t);
+                        edf_release_now(t);
                 /* The task should be running in the queue, otherwise signal 
                  * code will try to wake it up with fatal consequences.
                  */
@@ -1523,7 +1524,7 @@ static void hsb_wake_up_task(struct task_struct *task)
         }
         else if (is_tardy(task)) {
                 /* new sporadic release */
-                prepare_new_release(task);
+                edf_release_now(task);
                 sched_trace_job_release(task);
                 hsb_add_ready(task);
         }
@@ -1591,7 +1592,7 @@ static int hsb_mode_change(int new_mode)
               new_mode);
         if (new_mode == MODE_RT_RUN) {
                 start = jiffies + 20;
-                prepare_new_releases(&srt, start);
+                rerelease_all(&srt, edf_release_at);
                 be_prepare_new_releases(&be, start);
 
                 /* initialize per CPU state 
@@ -1613,7 +1614,7 @@ static int hsb_mode_change(int new_mode)
                         entry->cur_deadline             = 0;                    
                         list_add(&entry->list, &hsb_cpu_queue);
 
-                        prepare_new_releases(&entry->hrt.domain, start);
+                        rerelease_all(&entry->hrt.domain, edf_release_at);
                         prepare_hrt_release(&entry->hrt, start);
                 }               
                 spin_unlock(&hsb_cpu_lock);
diff --git a/kernel/sched_global_edf.c b/kernel/sched_global_edf.c
index 0781de139e..3ca46c1fb9 100644
--- a/kernel/sched_global_edf.c
+++ b/kernel/sched_global_edf.c
@@ -13,6 +13,7 @@
 
 #include <linux/litmus.h>
 #include <linux/sched_plugin.h>
+
 #include <linux/edf_common.h>
 #include <linux/sched_trace.h>
 
@@ -43,7 +44,7 @@ static spinlock_t gedf_cpu_lock = SPIN_LOCK_UNLOCKED;
 static LIST_HEAD(gedf_cpu_queue);
 
 
-static edf_domain_t gedf;
+static rt_domain_t gedf;
 
 #define DUMP(args...) TRACE(args)
 
@@ -98,7 +99,7 @@ static void adjust_cpu_queue(int exec_rt, jiffie_t deadline)
  *       hard to detect reliably. Too many schedules will hurt performance 
  *       but do not cause incorrect schedules.
  */
-static int gedf_check_resched(edf_domain_t *edf) 
+static int gedf_check_resched(rt_domain_t *edf) 
 {
         cpu_entry_t *last;
         int ret = 0;
@@ -161,7 +162,7 @@ static reschedule_check_t gedf_scheduler_tick(void)
                 if (want_resched != FORCE_RESCHED)
                 {
                         read_lock_irqsave(&gedf.ready_lock, flags);
-                        if (preemption_needed(&gedf, t))
+                        if (edf_preemption_needed(&gedf, t))
                         {
                                 want_resched = FORCE_RESCHED;
                                 set_will_schedule();
@@ -190,7 +191,7 @@ static int gedf_schedule(struct task_struct * prev,
         if (is_realtime(prev) && get_rt_flags(prev) == RT_F_SLEEP)
         {
                 DUMP("preparing %d for next period\n", prev->pid);
-                prepare_for_next_period(prev);  
+                edf_prepare_for_next_period(prev);      
         }
         
         if (get_rt_mode() == MODE_RT_RUN) {
@@ -199,7 +200,7 @@ static int gedf_schedule(struct task_struct * prev,
                 clear_will_schedule();
 
                 if (is_realtime(prev) && is_released(prev) && is_running(prev)
-                    && !preemption_needed(&gedf, prev)) {
+                    && !edf_preemption_needed(&gedf, prev)) {
                         /* Our current task's next job has already been 
                          * released and has higher priority than the highest
                          * prioriy waiting task; in other words: it is tardy.
@@ -302,7 +303,7 @@ static long gedf_prepare_task(struct task_struct * t)
                         /* The action is already on. 
                          * Prepare immediate release
                          */
-                        prepare_new_release(t);
+                        edf_release_now(t);
                 /* The task should be running in the queue, otherwise signal 
                  * code will try to wake it up with fatal consequences.
                  */
@@ -329,7 +330,7 @@ static void gedf_wake_up_task(struct task_struct *task)
         task->state = TASK_RUNNING;
         if (is_tardy(task)) {
                 /* new sporadic release */
-                prepare_new_release(task);
+                edf_release_now(task);
                 sched_trace_job_release(task);
                 add_ready(&gedf, task);
         }
@@ -387,7 +388,7 @@ static int gedf_mode_change(int new_mode)
 /*      printk(KERN_INFO "[%d] global edf: mode changed to %d\n", smp_processor_id(), 
         new_mode);*/
         if (new_mode == MODE_RT_RUN) {
-                prepare_new_releases(&gedf, jiffies + 10);
+                rerelease_all(&gedf, edf_release_at);
                 
                 /* initialize per CPU state 
                  * we can't do this at boot time because we don't know
@@ -500,7 +501,7 @@ static reschedule_check_t gedf_np_scheduler_tick(void)
  * sure that it is not the last entry or that a reschedule is not necessary.
  *
  */
-static int gedf_np_check_resched(edf_domain_t *edf) 
+static int gedf_np_check_resched(rt_domain_t *edf) 
 {
         cpu_entry_t *last;
         int ret = 0;
diff --git a/kernel/sched_part_edf.c b/kernel/sched_part_edf.c
index c382722a24..dee761525c 100644
--- a/kernel/sched_part_edf.c
+++ b/kernel/sched_part_edf.c
@@ -15,7 +15,7 @@
 
 
 typedef struct {
-        edf_domain_t            domain;
+        rt_domain_t             domain;
         int                     cpu;
         struct task_struct*     scheduled; /* only RT tasks */
         spinlock_t              lock;
@@ -29,7 +29,7 @@ typedef struct {
 #define task_edf(task)          remote_edf(get_partition(task))
 
 static void part_edf_domain_init(part_edf_domain_t* pedf, 
-                                 edf_check_resched_needed_t check,
+                                 check_resched_needed_t check,
                                  int cpu)
 {
         edf_domain_init(&pedf->domain, check);
@@ -44,17 +44,17 @@ DEFINE_PER_CPU(part_edf_domain_t, part_edf_domains);
  * the CPU of the partition.
  *
  */
-static int part_edf_check_resched(edf_domain_t *edf) 
+static int part_edf_check_resched(rt_domain_t *edf) 
 {
         part_edf_domain_t *pedf = container_of(edf, part_edf_domain_t, domain);
         int ret = 0;
 
         spin_lock(&pedf->lock);
        
-        /* because this is a callback from edf_domain_t we already hold
+        /* because this is a callback from rt_domain_t we already hold
          * the necessary lock for the ready queue
          */
-        if (preemption_needed(edf, pedf->scheduled)) {
+        if (edf_preemption_needed(edf, pedf->scheduled)) {
                 if (pedf->cpu == smp_processor_id())
                         set_tsk_need_resched(current);
                 else
@@ -71,7 +71,7 @@ static reschedule_check_t part_edf_scheduler_tick(void)
         unsigned long flags;
         struct task_struct *t = current;
         reschedule_check_t want_resched = NO_RESCHED;
-        edf_domain_t *edf       = local_edf;
+        rt_domain_t *edf       = local_edf;
         part_edf_domain_t *pedf = local_pedf;
 
         /* Check for inconsistency. We don't need the lock for this since
@@ -100,7 +100,7 @@ static reschedule_check_t part_edf_scheduler_tick(void)
                 if (want_resched != FORCE_RESCHED)
                 {
                         read_lock_irqsave(&edf->ready_lock, flags);
-                        if (preemption_needed(edf, t))
+                        if (edf_preemption_needed(edf, t))
                                 want_resched = FORCE_RESCHED;
                         read_unlock_irqrestore(&edf->ready_lock, flags);
                 }
@@ -114,16 +114,16 @@ static int part_edf_schedule(struct task_struct * prev,
 {
         int                     need_deactivate = 1;
         part_edf_domain_t*      pedf = local_pedf;
-        edf_domain_t*           edf  = &pedf->domain; 
+        rt_domain_t*            edf  = &pedf->domain; 
 
 
         if (is_realtime(prev) && get_rt_flags(prev) == RT_F_SLEEP)
-                prepare_for_next_period(prev);  
+                edf_prepare_for_next_period(prev);      
         
         if (get_rt_mode() == MODE_RT_RUN) {
                 write_lock(&edf->ready_lock);
                 if (is_realtime(prev) && is_released(prev) && is_running(prev)
-                    && !preemption_needed(edf, prev)) {
+                    && !edf_preemption_needed(edf, prev)) {
                         /* this really should only happen if the task has 
                          * 100% utilization... 
                          */
@@ -159,7 +159,7 @@ static int part_edf_schedule(struct task_struct * prev,
 
 static void part_edf_finish_switch(struct task_struct *prev) 
 {
-        edf_domain_t*   edf = local_edf;
+        rt_domain_t*    edf = local_edf;
 
         if (!is_realtime(prev) || !is_running(prev))
                 return;
@@ -195,7 +195,7 @@ static void part_edf_finish_switch(struct task_struct *prev)
  */
 static long part_edf_prepare_task(struct task_struct * t)
 {
-        edf_domain_t*   edf = task_edf(t);
+        rt_domain_t*    edf = task_edf(t);
 
 
         TRACE("[%d] part edf: prepare task %d on CPU %d\n", 
@@ -207,7 +207,7 @@ static long part_edf_prepare_task(struct task_struct * t)
                         /* The action is already on. 
                          * Prepare immediate release.
                          */
-                        prepare_new_release(t);         
+                        edf_release_now(t);             
                 /* The task should be running in the queue, otherwise signal 
                  * code will try to wake it up with fatal consequences.
                  */
@@ -220,7 +220,7 @@ static long part_edf_prepare_task(struct task_struct * t)
 
 static void part_edf_wake_up_task(struct task_struct *task) 
 {
-        edf_domain_t* edf;
+        rt_domain_t* edf;
 
         edf = task_edf(task);
 
@@ -237,7 +237,7 @@ static void part_edf_wake_up_task(struct task_struct *task)
         task->state = TASK_RUNNING;
         if (is_tardy(task)) {
                 /* new sporadic release */
-                prepare_new_release(task);
+                edf_release_now(task);
                 add_ready(edf, task);
 
         } else if (task->time_slice) {
@@ -290,7 +290,7 @@ static int part_edf_mode_change(int new_mode)
 
         if (new_mode == MODE_RT_RUN)
                 for_each_online_cpu(cpu)
-                        prepare_new_releases(remote_edf(cpu), jiffies);
+                        rerelease_all(remote_edf(cpu), edf_release_at);
         TRACE("[%d] part edf: mode changed to %d\n", 
                smp_processor_id(), new_mode);
         return 0;