C2 WIP2

1 files changed, 393 insertions, 0 deletions

diff --git a/litmus/sched_ext_res_c1.c b/litmus/sched_ext_res_c1.c
new file mode 100644
index 000000000000..63f6d821d2d4
--- /dev/null
+++ b/litmus/sched_ext_res_c1.c
@@ -0,0 +1,393 @@
+#include <linux/percpu.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+#include <litmus/sched_plugin.h>
+#include <litmus/preempt.h>
+#include <litmus/debug_trace.h>
+
+#include <litmus/litmus.h>
+#include <litmus/jobs.h>
+#include <litmus/budget.h>
+#include <litmus/litmus_proc.h>
+#include <litmus/sched_trace.h>
+
+#include <litmus/reservations/ext_reservation.h>
+#include <litmus/reservations/gedf_reservation.h>
+
+struct gedf_reservation_environment* gedf_env;
+
+struct cpu_time {
+        struct hrtimer timer;
+        lt_t last_update_time;
+};
+
+static DEFINE_PER_CPU(struct cpu_time, cpu_time);
+
+static enum hrtimer_restart on_budget_timeout(struct hrtimer *timer)
+{
+        litmus_reschedule_local();
+        return HRTIMER_NORESTART;
+}
+
+/*
+static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
+{
+        unsigned long flags;
+        enum hrtimer_restart restart = HRTIMER_NORESTART;
+        struct pres_cpu_state *state;
+        lt_t update, now;
+
+        state = container_of(timer, struct pres_cpu_state, timer);
+
+        // The scheduling timer should only fire on the local CPU, because
+        // otherwise deadlocks via timer_cancel() are possible.
+        // Note: this does not interfere with dedicated interrupt handling, as
+        // even under dedicated interrupt handling scheduling timers for
+        // budget enforcement must occur locally on each CPU.
+        //
+        BUG_ON(state->cpu != raw_smp_processor_id());
+
+        raw_spin_lock_irqsave(&state->lock, flags);
+        sup_update_time(&state->sup_env, litmus_clock());
+
+        update = state->sup_env.next_scheduler_update;
+        now = state->sup_env.env.current_time;
+
+        TRACE_CUR("on_scheduling_timer at %llu, upd:%llu (for cpu=%d)\n",
+                now, update, state->cpu);
+
+        if (update <= now) {
+                litmus_reschedule_local();
+        } else if (update != SUP_NO_SCHEDULER_UPDATE) {
+                hrtimer_set_expires(timer, ns_to_ktime(update));
+                restart = HRTIMER_RESTART;
+        }
+
+        raw_spin_unlock_irqrestore(&state->lock, flags);
+
+        return restart;
+}
+*/
+
+static struct task_struct* ext_res_schedule(struct task_struct * prev)
+{
+        int cpu = smp_processor_id();
+        lt_t delta, time_slice;
+        struct cpu_time* entry;
+        struct task_struct* next;
+
+        entry = this_cpu_ptr(&cpu_time);
+        delta = litmus_clock() - entry->last_update_time;
+
+        //TODO: implement per cpu lt_t to track time
+
+        gedf_env->env.ops->update_time(&gedf_env->env, delta, cpu);
+        next = gedf_env->env.ops->dispatch(&gedf_env->env, &time_slice, cpu);
+
+        entry->last_update_time = litmus_clock();
+
+        if (time_slice != ULLONG_MAX) {
+                hrtimer_start(&entry->timer,
+                        ns_to_ktime(entry->last_update_time + time_slice),
+                        HRTIMER_MODE_ABS_PINNED);
+        } else
+                hrtimer_try_to_cancel(&entry->timer);
+
+        sched_state_task_picked();
+
+        return next;
+}
+
+/* Called when a task should be removed from the ready queue.
+ */
+static void ext_res_task_block(struct task_struct *tsk)
+{
+        struct reservation* res;
+
+        TRACE_TASK(tsk, "thread suspends at %llu \n", litmus_clock());
+
+        res = (struct reservation*) tsk_rt(tsk)->plugin_state;
+        res->par_env->ops->remove_res(res->par_env, res, 0, 0);
+}
+
+
+/* Called when the state of tsk changes back to TASK_RUNNING.
+ * We need to requeue the task.
+ */
+static void ext_res_task_resume(struct task_struct  *tsk)
+{
+        struct reservation* res;
+
+        TRACE_TASK(tsk, "thread wakes up at %llu\n", litmus_clock());
+
+        res = (struct reservation*) tsk_rt(tsk)->plugin_state;
+        res->par_env->ops->add_res(res->par_env, res, 0);
+}
+
+static long ext_res_admit_task(struct task_struct *tsk)
+{
+        long err = 0;
+
+        struct gedf_task_reservation* gedf_task_res;
+
+        err = alloc_gedf_task_reservation(&gedf_task_res, tsk);
+        if (err)
+                return err;
+
+        gedf_task_res->gedf_res.res.par_env = &gedf_env->env;
+
+        //TODO: for checkpoint 2, need to find component and insert into it
+
+        return 0;
+}
+
+static void ext_res_task_new(struct task_struct *tsk, int on_runqueue,
+                          int is_running)
+{
+        struct reservation* res;
+        lt_t now = litmus_clock();
+
+        TRACE_TASK(tsk, "new RT task %llu (on_rq:%d, running:%d)\n",
+                   now, on_runqueue, is_running);
+
+        res = (struct reservation*)tsk_rt(tsk)->plugin_state;
+
+        release_at(tsk, now);
+        res->replenishment_time = now;
+
+        res->par_env->ops->add_res(res->par_env, res, 0);
+
+        if (is_running)
+                litmus_reschedule_local();
+}
+
+/*
+static bool pres_fork_task(struct task_struct *tsk)
+{
+        TRACE_CUR("is forking\n");
+        TRACE_TASK(tsk, "forked child rt:%d cpu:%d task_cpu:%d "
+                        "wcet:%llu per:%llu\n",
+                is_realtime(tsk),
+                tsk_rt(tsk)->task_params.cpu,
+                task_cpu(tsk),
+                tsk_rt(tsk)->task_params.exec_cost,
+                tsk_rt(tsk)->task_params.period);
+
+        // We always allow forking.
+        // The newly forked task will be in the same reservation.
+        return true;
+}
+*/
+
+static void ext_res_task_exit(struct task_struct *tsk)
+{
+        struct reservation* res;
+        struct reservation_environment* par_env;
+
+        res = (struct reservation*)tsk_rt(tsk)->plugin_state;
+        par_env = res->par_env;
+
+        par_env->ops->remove_res(par_env, res, 1, 0);
+
+        TRACE_TASK(tsk, "task exits at %llu \n", litmus_clock());
+}
+
+/* used by task budget tracking in budget.c. Since we have tasks in containers that track
+ * budget, we don't need this. Furthermore, this scheme doesn't work efficiently with
+ * multicore reservations
+ */
+/*
+static void pres_current_budget(lt_t *used_so_far, lt_t *remaining)
+{
+        struct pres_task_state *tstate = get_pres_state(current);
+        struct pres_cpu_state *state;
+
+        // FIXME: protect against concurrent task_exit()
+
+        local_irq_disable();
+
+        state = cpu_state_for(tstate->cpu);
+
+        raw_spin_lock(&state->lock);
+
+        sup_update_time(&state->sup_env, litmus_clock());
+        if (remaining)
+                *remaining = tstate->client->reservation->cur_budget;