Merged with ce domains

1 files changed, 31 insertions, 74 deletions

diff --git a/litmus/ce_domain.c b/litmus/ce_domain.c
index 5b4fd1cb438..ac6cc14d44f 100644
--- a/litmus/ce_domain.c
+++ b/litmus/ce_domain.c
@@ -6,7 +6,9 @@
 #include <litmus/debug_trace.h>
 #include <litmus/rt_param.h>
 #include <litmus/domain.h>
+#include <litmus/event_group.h>
 #include <litmus/sched_mc.h>
+#include <litmus/ce_domain.h>
 
 /*
  * Called for:
@@ -18,50 +20,26 @@ void ce_requeue(domain_t *dom, struct task_struct *ts)
 {
         const struct ce_dom_data *ce_data = dom->data;
         const int idx = tsk_mc_data(ts)->mc_task.lvl_a_id;
-        const struct ce_dom_pid_entry *pid_entry =
-                &ce_data->pid_entries[idx];
-        const int just_finished = tsk_rt(ts)->job_params.job_no;
-        const int expected_job = pid_entry->expected_job;
+        const unsigned int just_finished = tsk_rt(ts)->job_params.job_no;
+        const unsigned int expected_job =
+                mc_ce_get_expected_job(ce_data->cpu, idx);
         const int asleep = RT_F_SLEEP == get_rt_flags(ts);
 
-        TRACE_TASK(ts, "entered ce_requeue. asleep: %d  just_finished: %4d  "
-                        "expected_job: %4d\n",
+        TRACE_MC_TASK(ts, "entered ce_requeue. asleep: %d  just_finished: %3u  "
+                        "expected_job: %3u",
                         asleep, just_finished, expected_job);
 
         /* When coming from job completion, the task will be asleep. */
         if (asleep && just_finished < expected_job) {
-                /* this job is running behind, so don't put it to sleep */
-                set_rt_flags(ts, RT_F_RUNNING);
-                TRACE_TASK(ts, "appears behind, setting it to running again\n");
+                TRACE_MC_TASK(ts, "appears behind");
         } else if (asleep && expected_job < just_finished) {
-                printk(KERN_CRIT "job %d completed in expected job %d which "
-                                "seems too early\n", just_finished,
+                TRACE_MC_TASK(ts, "job %u completed in expected job %u which "
+                                "seems too early", just_finished,
                                 expected_job);
-                BUG();
         }
 }
 
 /*
- * Called when a task exits the system.
- */
-void ce_exit(domain_t *dom, struct task_struct *ts)
-{
-        struct ce_dom_data *ce_data = dom->data;
-        const int lvl_a_id = tsk_mc_data(ts)->mc_task.lvl_a_id;
-        struct pid *pid;
-
-        BUG_ON(task_cpu(ts) != get_partition(ts));
-        BUG_ON(CRIT_LEVEL_A != tsk_mc_crit(ts));
-        BUG_ON(lvl_a_id >= ce_data->num_pid_entries);
-        pid = ce_data->pid_entries[lvl_a_id].pid;
-        BUG_ON(!pid);
-        put_pid(pid);
-        ce_data->pid_entries[lvl_a_id].pid = NULL;
-        if (ce_data->should_schedule == ts)
-                ce_data->should_schedule = NULL;
-}
-
-/*
  * ce_take_ready and ce_peek_ready
  */
 struct task_struct* ce_peek_and_take_ready(domain_t *dom)
@@ -71,57 +49,36 @@ struct task_struct* ce_peek_and_take_ready(domain_t *dom)
         const int exists = NULL != ce_data->should_schedule;
         const int blocked = exists && !is_running(ce_data->should_schedule);
 
-        /* Return the task we should schedule if it is not blocked. If it is
-         * asleep, return it anyway, because the MC-scheduler might as about
-         * ghost jobs.
-         */
+        /* Return the task we should schedule if it is not blocked or sleeping. */
         if (exists && !blocked)
                 ret = ce_data->should_schedule;
         return ret;
 }
 
-int ce_higher_prio(domain_t *dom, struct task_struct *_a,
-                struct task_struct *_b)
+int ce_higher_prio(struct task_struct *_a, struct task_struct *_b)
 {
         const struct task_struct *a = _a;
-        struct ce_dom_data *ce_data = dom->data;
+        const domain_t *dom = get_task_domain(a);
+        const struct ce_dom_data *ce_data = dom->data;
         return (a == ce_data->should_schedule);
 }
 
-void __mc_ce_timer_callback(struct hrtimer *timer);
-static enum hrtimer_restart ce_timer_function(struct hrtimer *timer)
-{
-        /* need to lock? */
-        __mc_ce_timer_callback(timer);
-        return HRTIMER_RESTART;
-}
-
-void mc_ce_release_at(struct task_struct*, lt_t);
-void ce_start(struct task_struct *ts, lt_t start)
-{
-        mc_ce_release_at(ts, start);
-}
-
-long mc_ce_activate_plugin(void);
-domain_t *ce_domain_for(int);
-long ce_activate_plugin(void)
-{
-        domain_t *dom;
-        struct ce_dom_data *ce_data;
-        int cpu;
-
-        /* first change the timer callback function */
-        for_each_online_cpu(cpu) {
-                dom = ce_domain_for(cpu);
-                ce_data = dom->data;
-                ce_data->timer.function = ce_timer_function;
-        }
-        /* then run the regular CE activate plugin */
-        return mc_ce_activate_plugin();
-}
-
-long mc_ce_deactivate_plugin(void);
-long ce_deactivate_plugin(void)
+void ce_domain_init(domain_t *dom,
+                raw_spinlock_t *lock,
+                requeue_t requeue,
+                peek_ready_t peek_ready,
+                take_ready_t take_ready,
+                preempt_needed_t preempt_needed,
+                task_prio_t task_prio,
+                struct ce_dom_data *dom_data,
+                const int cpu,
+                ce_timer_callback_t ce_timer_callback)
 {
-        return mc_ce_deactivate_plugin();
+        domain_init(dom, lock, requeue, peek_ready, take_ready, preempt_needed,
+                        task_prio);
+        dom->data = dom_data;
+        dom_data->cpu = cpu;
+        hrtimer_start_on_info_init(&dom_data->timer_info);
+        hrtimer_init(&dom_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+        dom_data->timer.function = ce_timer_callback;
 }