MC-EDF addedwip-mc-bipasa

1 files changed, 678 insertions, 0 deletions

diff --git a/litmus/sched_mc_edf.c b/litmus/sched_mc_edf.c
new file mode 100644
index 000000000000..bdd518523cff
--- /dev/null
+++ b/litmus/sched_mc_edf.c
@@ -0,0 +1,678 @@
+/*
+ * kernel/sched_mc_edf.c
+ *
+ * Implementation of the MC-EDF scheduler plugin.
+ * Based on kern/sched_part_edf.c and kern/sched_gsn_edf.c.
+ *
+ * Suspensions and non-preemptable sections are supported.
+ * Priority inheritance is not supported.
+ */
+
+#include <linux/percpu.h>
+#include <linux/sched.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/module.h>
+
+#include <litmus/litmus.h>
+#include <litmus/jobs.h>
+#include <litmus/preempt.h>
+#include <litmus/sched_plugin.h>
+#include <litmus/edf_common.h>
+#include <litmus/sched_trace.h>
+#include <litmus/trace.h>
+#include <litmus/budget.h>
+
+typedef struct {
+        int                     curr_cri; // mc-bipasa
+        rt_domain_t             high_domain; // mc-bipasa
+        rt_domain_t             domain;
+        int                     cpu;
+        struct task_struct*     scheduled; /* only RT tasks */
+/*
+ * scheduling lock slock
+ * protects the domain and serializes scheduling decisions
+ */
+#define slock domain.ready_lock
+
+} mcedf_domain_t;
+
+DEFINE_PER_CPU(mcedf_domain_t, mcedf_domains);
+
+#define local_edf               (&__get_cpu_var(mcedf_domains).domain)
+#define local_mcedf             (&__get_cpu_var(mcedf_domains))
+#define remote_edf(cpu)         (&per_cpu(mcedf_domains, cpu).domain)
+#define remote_mcedf(cpu)       (&per_cpu(mcedf_domains, cpu))
+#define task_edf(task)          remote_edf(get_partition(task))
+#define task_mcedf(task)        remote_mcedf(get_partition(task))//mc-bipasa always 0
+
+
+static void mcedf_domain_init(mcedf_domain_t* mcedf,
+                               check_resched_needed_t check,
+                               release_jobs_t release,
+                               int cpu)
+{ 
+        // high >= 1, low = 0
+        mcedf->curr_cri                 = 0; 
+        edf_mc_domain_init(&mcedf->high_domain, check, release, 1); // mc-bipasa
+        edf_mc_domain_init(&mcedf->domain, check, release, 0); // mc-bipasa
+        mcedf->cpu                      = cpu;
+        mcedf->scheduled                = NULL;
+}
+
+static void requeue(struct task_struct* t, rt_domain_t *edf)
+{
+        if (t->state != TASK_RUNNING)
+                TRACE_TASK(t, "requeue: !TASK_RUNNING\n");
+
+        set_rt_flags(t, RT_F_RUNNING);
+        if (is_released(t, litmus_clock()))
+                __add_ready(edf, t);
+        else
+                add_release(edf, t); /* it has got to wait */
+}
+
+/* we assume the lock is being held */
+static void preempt(mcedf_domain_t *mcedf)
+{
+        preempt_if_preemptable(mcedf->scheduled, mcedf->cpu);
+}
+
+#ifdef CONFIG_LITMUS_LOCKING
+
+static void boost_priority(struct task_struct* t)
+{
+        unsigned long           flags;
+        mcedf_domain_t*         mcedf = task_mcedf(t);
+        lt_t                    now;
+
+        raw_spin_lock_irqsave(&mcedf->slock, flags);
+        now = litmus_clock();
+
+        TRACE_TASK(t, "priority boosted at %llu\n", now);
+
+        tsk_rt(t)->priority_boosted = 1;
+        tsk_rt(t)->boost_start_time = now;
+
+        if (mcedf->scheduled != t) {
+                /* holder may be queued: first stop queue changes */
+                raw_spin_lock(&mcedf->domain.release_lock);
+                if (is_queued(t) &&
+                    /* If it is queued, then we need to re-order. */
+                    bheap_decrease(edf_ready_order, tsk_rt(t)->heap_node) &&
+                    /* If we bubbled to the top, then we need to check for preemptions. */
+                    edf_preemption_needed(&mcedf->domain, mcedf->scheduled))
+                                preempt(mcedf);
+                raw_spin_unlock(&mcedf->domain.release_lock);
+        } /* else: nothing to do since the job is not queued while scheduled */
+
+        raw_spin_unlock_irqrestore(&mcedf->slock, flags);
+}
+
+static void unboost_priority(struct task_struct* t)
+{
+        unsigned long           flags;
+        mcedf_domain_t*         mcedf = task_mcedf(t);
+        lt_t                    now;
+
+        raw_spin_lock_irqsave(&mcedf->slock, flags);
+        now = litmus_clock();
+
+        /* assumption: this only happens when the job is scheduled */
+        BUG_ON(mcedf->scheduled != t);
+
+        TRACE_TASK(t, "priority restored at %llu\n", now);
+
+        /* priority boosted jobs must be scheduled */
+        BUG_ON(mcedf->scheduled != t);
+
+        tsk_rt(t)->priority_boosted = 0;
+        tsk_rt(t)->boost_start_time = 0;
+
+        /* check if this changes anything */
+        if (edf_preemption_needed(&mcedf->domain, mcedf->scheduled))
+                preempt(mcedf);
+
+        raw_spin_unlock_irqrestore(&mcedf->slock, flags);
+}
+
+#endif
+
+/* This check is trivial in partioned systems as we only have to consider
+ * the CPU of the partition.
+ */
+static int mcedf_check_resched(rt_domain_t *edf)
+{
+        mcedf_domain_t *mcedf = container_of(edf, mcedf_domain_t, domain);
+
+        /* because this is a callback from rt_domain_t we already hold
+         * the necessary lock for the ready queue
+         */
+        if (edf_preemption_needed(edf, mcedf->scheduled)) {
+                preempt(mcedf);
+                return 1;
+        } else
+                return 0;
+}
+
+static void job_completion(struct task_struct* t, int forced)
+{
+        sched_trace_task_completion(t,forced);
+        TRACE_TASK(t, "job_completion().\n");
+
+        set_rt_flags(t, RT_F_SLEEP);
+
+        prepare_for_next_period(t); // check
+        /*if (forced) {
+          server_release(t);
+        } else {
+          task_release(t);
+        }*/
+}
+
+static void mcedf_tick(struct task_struct *t)
+{
+        mcedf_domain_t *mcedf = local_mcedf;
+
+        /* Check for inconsistency. We don't need the lock for this since
+         * ->scheduled is only changed in schedule, which obviously is not
+         *  executing in parallel on this CPU
+         */
+        BUG_ON(is_realtime(t) && t != mcedf->scheduled);
+
+        if (is_realtime(t) && budget_enforced(t) && budget_exhausted(t)) {
+                if (!is_np(t)) {
+                        litmus_reschedule_local();
+                        TRACE("mcedf_scheduler_tick: "
+                              "%d is preemptable "
+                              " => FORCE_RESCHED\n", t->pid);
+                } else if (is_user_np(t)) {
+                        TRACE("mcedf_scheduler_tick: "
+                              "%d is non-preemptable, "
+                              "preemption delayed.\n", t->pid);
+                        request_exit_np(t);
+                }
+        }
+}
+
+static struct task_struct* mcedf_schedule(struct task_struct * prev)
+{
+        mcedf_domain_t*         mcedf = local_mcedf; 
+        rt_domain_t*            edf  = &mcedf->domain; 
+        struct task_struct*     next;
+
+