Implementation of EDZL

This patch implements the global EDZL scheduler.  It is based
heavily on the GSN-EDF implementation.  Timers are used to detect
zero-laxity points and issue the proper rescheduling operations.

1 files changed, 98 insertions, 0 deletions

diff --git a/litmus/edzl_common.c b/litmus/edzl_common.c
new file mode 100644
index 000000000000..f925901703ab
--- /dev/null
+++ b/litmus/edzl_common.c
@@ -0,0 +1,98 @@
+/*
+ * kernel/edzl_common.c
+ *
+ * Common functions for EDZL based scheduler.
+ */
+
+#include <linux/percpu.h>
+#include <linux/sched.h>
+#include <linux/list.h>
+
+#include <litmus/litmus.h>
+#include <litmus/sched_plugin.h>
+#include <litmus/sched_trace.h>
+
+#include <litmus/edf_common.h>
+#include <litmus/edzl_common.h>
+
+int edzl_higher_prio(struct task_struct* first,
+                    struct task_struct* second)
+{
+        struct task_struct *first_task = first;
+        struct task_struct *second_task = second;
+
+        /* There is no point in comparing a task to itself. */
+        if (first && first == second) {
+                TRACE_TASK(first,
+                           "WARNING: pointless edf priority comparison.\n");
+                return 0;
+        }
+
+
+        /* Check for inherited priorities. Change task
+         * used for comparison in such a case.
+         */
+        if (first && first->rt_param.inh_task)
+                first_task = first->rt_param.inh_task;
+        if (second && second->rt_param.inh_task)
+                second_task = second->rt_param.inh_task;
+
+        /* null checks & rt checks */
+        if(!first_task)
+                return 0;
+        else if(!second_task || !is_realtime(second_task))
+                return 1;
+
+        
+        if(likely(get_zerolaxity(first_task) == get_zerolaxity(second_task)))
+        {
+                /* edf order if both tasks have the same laxity state */
+                return(edf_higher_prio(first_task, second_task));
+        }
+        else
+        {
+                return(get_zerolaxity(first_task));
+        }
+}
+
+int edzl_ready_order(struct bheap_node* a, struct bheap_node* b)
+{
+        return edzl_higher_prio(bheap2task(a), bheap2task(b));
+}
+
+void edzl_domain_init(rt_domain_t* rt, check_resched_needed_t resched,
+                      release_jobs_t release)
+{
+        rt_domain_init(rt,  edzl_ready_order, resched, release);
+}
+
+/* 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!
+ */
+int edzl_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 (!__jobs_pending(rt))
+                return 0;
+        /* we need to reschedule if t doesn't exist */
+        if (!t)
+                return 1;
+        /* make sure to get non-rt stuff out of the way */
+        if (!is_realtime(t))
+                return 1;
+
+        /* NOTE: We cannot check for non-preemptibility since we
+         *       don't know what address space we're currently in.
+         */
+
+        /* Detect zero-laxity as needed.  Easier to do it here than in tick.
+           (No timer is used to detect zero-laxity while a job is running.) */
+        if(unlikely(!get_zerolaxity(t) && laxity_remaining(t) == 0))
+        {
+                set_zerolaxity(t, 1);
+        }
+
+        return edzl_higher_prio(__next_ready(rt), t);
+}