7 files changed, 204 insertions, 167 deletions

diff --git a/include/litmus/reservations/ext_reservation.h b/include/litmus/reservations/ext_reservation.h
index 68784f71a268..40c9cd9e098e 100644
--- a/include/litmus/reservations/ext_reservation.h
+++ b/include/litmus/reservations/ext_reservation.h
@@ -25,14 +25,12 @@ typedef void (*drain_budget_t) (
 
 typedef struct task_struct* (*dispatch_client_t) (
         struct reservation *reservation,
-        lt_t now,
         int cpu
 );
 
 /* When reservation is scheduled. */
 typedef void (*on_schedule_t) (
         struct reservation *reservation,
-        lt_t now,
         int cpu
 );
 
@@ -59,16 +57,12 @@ struct reservation {
 
         /* exact meaning defined by impl. */
         lt_t priority;
-        lt_t cur_budget;
         lt_t replenishment_time;
 
         /* budget stats */
         lt_t budget_consumed; /* how much budget consumed in this allocation cycle? */
         lt_t budget_consumed_total;
 
-        /* list of registered budget callbacks */
-        struct budget_notifier_list budget_notifiers;
-
         /* for memory reclamation purposes */
         struct list_head all_list;
 
@@ -84,7 +78,10 @@ struct reservation {
         struct list_head ln;
 };
 
-void init_ext_reservation(struct reservation* res);
+void init_ext_reservation(
+        struct reservation* res,
+        unsigned int id,
+        struct reservation_ops* ops);
 
 void clean_up_ext_reservation(struct reservation* res);
 
@@ -96,12 +93,10 @@ typedef void (*env_update_time_t) (
 
 typedef struct task_struct* (*env_dispatch_t) (
         struct reservation_environment* env,
-        lt_t now,
         int cpu);
 
 typedef void (*env_resume_t) (
         struct reservation_environment* env,
-        lt_t now,
         int cpu);
 
 typedef void (*env_suspend_t) (
diff --git a/include/litmus/reservations/gedf_reservation.h b/include/litmus/reservations/gedf_reservation.h
index 57f2fa7f00fc..2adaaabbcaf4 100644
--- a/include/litmus/reservations/gedf_reservation.h
+++ b/include/litmus/reservations/gedf_reservation.h
@@ -8,22 +8,22 @@
 #include <litmus/reservations/ext_reservation.h>
 
 /* ************************************************************************** */
-struct cpu_entry {
-        int id;
-        struct hrtimer timer;
-        struct bheap_node* hn;
-        struct reservation* linked;
-        struct reservation* scheduled;
-};
-
 struct gedf_reservation {
         struct reservation res;
         struct cpu_entry* linked_on;
-        struct cpu_entry* scheduled_on;
+        lt_t cur_budget;
         int will_remove;
         int blocked;
 };
 
+struct cpu_entry {
+        int id;
+        struct hrtimer timer;
+        struct bheap_node* hn;
+        struct gedf_reservation* linked;
+        struct gedf_reservation* scheduled;
+};
+
 struct gedf_task_reservation {
         struct gedf_reservation gedf_res;
         struct task_struct* task;
@@ -52,13 +52,15 @@ long alloc_gedf_task_reservation(
 /* environment for scheduling reservations via gedf */
 struct gedf_reservation_environment {
         struct reservation_environment env;
+
+        /* list of all reservations scheduled by environment */
         struct list_head all_reservations;
+
         /* number of active cpus in reservation */
-        int num_cpus;
+        volatile int num_cpus;
+
         /* array of gedf cpu entries */
         struct cpu_entry cpu_entries[NR_CPUS];
-        /* smp_processor_id to environment cpu array offset mapping */
-        int cpu_mapping[NR_CPUS];
 
         /* used to order cpus for gedf purposes */
         struct bheap cpu_heap;
@@ -69,7 +71,7 @@ struct gedf_reservation_environment {
 
 long alloc_gedf_reservation_environment(
         struct gedf_reservation_environment** _env,
-        int num_cpus
+        int max_cpus
 );
 
 #endif
diff --git a/include/litmus/reservations/table_driven_ext_reservation.h b/include/litmus/reservations/table_driven_ext_reservation.h
index 414791ee9261..51c32eadb419 100644
--- a/include/litmus/reservations/table_driven_ext_reservation.h
+++ b/include/litmus/reservations/table_driven_ext_reservation.h
@@ -12,23 +12,21 @@ struct cpu_entry {
         struct reservation* scheduled;
 };
 
-struct gedf_reservation {
+struct mtd_reservation {
         struct reservation res;
-        struct cpu_entry linked_on;
-        struct cpu_entry scheduled_on;
-        int will_remove;
-        int blocked;
-        lt_t period;
-        lt_t relative_deadline;
-        lt_t exec_cost;
+        lt_t major_cycle;
+        unsigned int interval_index[NR_CPUS];
+        unsigned int num_intervals[NR_CPUS];
+        struct lt_interval* intervals[NR_CPUS];
+
+        int num_cur_intervals;
+        struct lt_interval cur_interval[NR_CPUS];
+        lt_t major_cycle_start;
 };
 
-long alloc_gedf_reservation(
-        struct reservation** _res,
-        int id,
-        lt_t exec_cost,
-        lt_t period,
-        lt_t relative_deadline
+long alloc_mtd_reservation(
+        struct reservation_config* config,
+        struct reservation** _res
 );
 
 /* environment for scheduling reservations via gedf */
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 9b291343714f..29bf745b4497 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -110,6 +110,27 @@ struct reservation_config {
         };
 };
 
+struct ext_reservation_config {
+        unsigned int id;
+        lt_t priority;
+        int  cpu;
+
+        union {
+                struct {
+                        lt_t period;
+                        lt_t budget;
+                        lt_t relative_deadline;
+                        lt_t offset;
+                } polling_params;
+
+                struct {
+                        lt_t major_cycle_length;
+                        unsigned int num_intervals;
+                        struct lt_interval __user *intervals;
+                } table_driven_params;
+        };
+};
+
 /* regular sporadic task support */
 
 struct rt_task {
diff --git a/litmus/reservations/ext_reservation.c b/litmus/reservations/ext_reservation.c
index 9397241faf99..c39bbae08513 100644
--- a/litmus/reservations/ext_reservation.c
+++ b/litmus/reservations/ext_reservation.c
@@ -6,9 +6,13 @@
 extern struct kmem_cache* bheap_node_cache;
 extern struct kmem_cache* release_heap_cache;
 
-void init_ext_reservation(struct reservation* res)
+void init_ext_reservation(
+        struct reservation* res,
+        unsigned int id,
+        struct reservation_ops* ops)
 {
-        memset(res, 0, sizeof(struct reservation));
+        res->id = id;
+        res->ops = ops;
         res->heap_node = kmem_cache_alloc(bheap_node_cache, GFP_ATOMIC);
         res->rel_heap = kmem_cache_alloc(release_heap_cache, GFP_ATOMIC);
         bheap_node_init(&res->heap_node, res);
diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index 5951963e03ec..aa5eb9d4b821 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -59,7 +59,7 @@ static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
         a = _a->value;
         b = _b->value;
         /* use higher prio here because prio is deadline value */
-        return higher_prio(a->linked, b->linked);
+        return higher_prio(&a->linked->res, &b->linked->res);
 }
 
 static void update_cpu_position(struct cpu_entry* entry, struct bheap* cpu_heap)
@@ -76,14 +76,16 @@ static struct cpu_entry* lowest_prio_cpu(struct bheap* cpu_heap)
         return hn->value;
 }
 
-static int edf_preemption_needed(rt_domain_t* rt, struct reservation* res)
+static int edf_preemption_needed(
+        struct gedf_reservation_environment* gedf_env,
+        struct gedf_reservation* gedf_res)
 {
         /* we need the read lock for edf_ready_queue */
         /* no need to preempt if there is nothing pending */
-        if (bheap_empty(&rt->ready_queue))
+        if (bheap_empty(&gedf_env->domain.ready_queue))
                 return 0;
         /* we need to reschedule if res doesn't exist */
-        if (!res)
+        if (!gedf_res)
                 return 1;
 
         /* NOTE: We cannot check for non-preemptibility since we
@@ -91,7 +93,7 @@ static int edf_preemption_needed(rt_domain_t* rt, struct reservation* res)
          */
 
         /* reversed */
-        return higher_prio(res, __next_ready_res(rt));
+        return higher_prio(&gedf_res->res, __next_ready_res(&gedf_env->domain));
 }
 
 /* ******************************************************************************** */
@@ -107,60 +109,61 @@ static enum hrtimer_restart timer_callback(struct hrtimer* timer)
         return HRTIMER_NORESTART;
 }
 
-static void requeue(rt_domain_t* domain, struct reservation* res) {
-        BUG_ON(!res);
-        BUG_ON(is_queued_res(res));
+static void requeue(
+        struct gedf_reservation_environment* gedf_env,
+        struct gedf_reservation* gedf_res)
+{
+        BUG_ON(!gedf_res);
+        BUG_ON(is_queued_res(&gedf_res->res));
 
-        if (lt_before_eq(res->replenishment_time, litmus_clock()))
-                __add_ready_res(domain, res);
+        if (lt_before_eq(gedf_res->res.replenishment_time, litmus_clock()))
+                __add_ready_res(&gedf_env->domain, &gedf_res->res);
         else
-                __add_release_res(domain, res);
+                __add_release_res(&gedf_env->domain, &gedf_res->res);
 
 }
 
 static void link_task_to_cpu(
+        struct gedf_reservation_environment* gedf_env,
         struct gedf_reservation* linked,
-        struct cpu_entry* entry,
-        struct gedf_reservation_environment* gedf_env)
+        struct cpu_entry* entry)
 {
-        struct cpu_entry* sched = NULL;
-        struct reservation* tmp;
 
         if (entry->linked)
-                ((struct gedf_reservation*)entry->linked)->linked_on = NULL;
+                entry->linked->linked_on = NULL;
 
         if (linked)
                 linked->linked_on = entry;
 
-        entry->linked = &linked->res;
+        entry->linked = linked;
         update_cpu_position(entry, &gedf_env->cpu_heap);
 }
 
 static void unlink(
-        struct gedf_reservation* res,
-        struct gedf_reservation_environment* gedf_env)
-{
-        BUG_ON(!res->linked_on);
-        if (res->linked_on) {
-                link_task_to_cpu(NULL, res->linked_on, gedf_env);
-                res->linked_on = NULL;
-        } else if (is_queued_res(&res->res)) {
-                remove_res(&gedf_env->domain, &res->res);
+        struct gedf_reservation_environment* gedf_env,
+        struct gedf_reservation* gedf_res)
+{
+        BUG_ON(!gedf_res->linked_on);
+        if (gedf_res->linked_on) {
+                link_task_to_cpu(gedf_env, NULL, gedf_res->linked_on);
+                gedf_res->linked_on = NULL;
+        } else if (is_queued_res(&gedf_res->res)) {
+                remove_res(&gedf_env->domain, &gedf_res->res);
         }
 }
 
-static void check_for_preemptions(struct gedf_reservation_environment* env)
+static void check_for_preemptions(struct gedf_reservation_environment* gedf_env)
 {
-        struct gedf_reservation* res;
+        struct gedf_reservation* gedf_res;
         struct cpu_entry* last;
 
-        for (last = lowest_prio_cpu(&env->cpu_heap);
-                        edf_preemption_needed(&env->domain, last->linked);
-                        last = lowest_prio_cpu(&env->cpu_heap)) {
-                res = (struct gedf_reservation*)__take_ready_res(&env->domain);
+        for (last = lowest_prio_cpu(&gedf_env->cpu_heap);
+                        edf_preemption_needed(gedf_env, last->linked);
+                        last = lowest_prio_cpu(&gedf_env->cpu_heap)) {
+                gedf_res = (struct gedf_reservation*)__take_ready_res(&gedf_env->domain);
                 if (last->linked && last->linked->cur_budget)
-                        requeue(&env->domain, last->linked);
-                link_task_to_cpu(res, last, env);
+                        requeue(gedf_env, last->linked);
+                link_task_to_cpu(gedf_env, gedf_res, last);
                 preempt(last);
         }
 }
@@ -190,23 +193,20 @@ static void gedf_on_preempt(
 
 static void gedf_on_schedule(
         struct reservation *res,
-        lt_t now,
         int cpu)
 {
-        res->env->ops->resume(res->env, now, cpu);
+        res->env->ops->resume(res->env, cpu);
 }
 
 static struct task_struct* gedf_dispatch_client(
         struct reservation* res,
-        lt_t now,
         int cpu)
 {
-        return res->env->ops->dispatch(res->env, now, cpu);
+        return res->env->ops->dispatch(res->env, cpu);
 }
 
 static struct task_struct* gedf_task_dispatch_client(
         struct reservation* res,
-        lt_t now,
         int cpu)
 {
         return ((struct gedf_task_reservation*)res)->task;
@@ -219,9 +219,9 @@ static void gedf_replenish_budget(
         struct gedf_container_reservation* gedf_cont_res =
                 (struct gedf_container_reservation*)res;
         res->budget_consumed = 0;
-        res->cur_budget = gedf_cont_res->max_budget;
-        res->priority = res->replenishment_time + gedf_cont_res->relative_deadline;
+        gedf_cont_res->gedf_res.cur_budget = gedf_cont_res->max_budget;
         res->replenishment_time += gedf_cont_res->period;
+        res->priority = res->replenishment_time + gedf_cont_res->relative_deadline;
 }
 
 static void gedf_task_replenish_budget(
@@ -229,6 +229,8 @@ static void gedf_task_replenish_budget(
         int cpu)
 {
         struct task_struct* t = ((struct gedf_task_reservation*)res)->task;
+        struct gedf_reservation* gedf_res = container_of(res, struct gedf_reservation, res);
+
         if (is_completed(t)) {
                 sched_trace_task_completion(t, 0);
                 prepare_for_next_period(t);
@@ -243,7 +245,7 @@ static void gedf_task_replenish_budget(
                 TRACE_TASK(t, "overrun budget!\n");
         }
         res->budget_consumed = 0;
-        res->cur_budget = get_exec_cost(t);
+        gedf_res->cur_budget = get_exec_cost(t);
 }
 
 static void gedf_drain_budget(
@@ -251,10 +253,12 @@ static void gedf_drain_budget(
         lt_t how_much,
         int cpu)
 {
-        if (how_much > res->cur_budget)
-                res->cur_budget = 0;
+        struct gedf_reservation* gedf_res = container_of(res, struct gedf_reservation, res);
+
+        if (how_much > gedf_res->cur_budget)
+                gedf_res->cur_budget = 0;
         else
-                res->cur_budget -= how_much;
+                gedf_res->cur_budget -= how_much;
         res->budget_consumed += how_much;
         res->budget_consumed_total += how_much;
 
@@ -267,10 +271,12 @@ static void gedf_task_drain_budget(
         int cpu)
 {
         struct task_struct* t = ((struct gedf_task_reservation*)res)->task;
-        if (how_much > res->cur_budget || is_completed(t))
-                res->cur_budget = 0;
+        struct gedf_reservation* gedf_res = container_of(res, struct gedf_reservation, res);
+
+        if (how_much > gedf_res->cur_budget || is_completed(t))
+                gedf_res->cur_budget = 0;
         else
-                res->cur_budget -= how_much;
+                gedf_res->cur_budget -= how_much;
         res->budget_consumed += how_much;
         res->budget_consumed_total += how_much;
 }
@@ -298,20 +304,12 @@ long alloc_gedf_task_reservation(
         struct task_struct* task)
 {
         struct gedf_task_reservation* gedf_task_res;
-        struct gedf_reservation* gedf_res;
         gedf_task_res = kzalloc(sizeof(*gedf_task_res), GFP_KERNEL);
         if (!gedf_task_res)
                 return -ENOMEM;
-        gedf_res = &gedf_task_res->gedf_res;
 
-        init_ext_reservation(&gedf_res->res);
-        gedf_res->res.id = task->pid;
-        gedf_res->res.ops = &gedf_task_ops;
-
-        gedf_res->linked_on = NULL;
-        gedf_res->scheduled_on = NULL;
-        gedf_res->will_remove = 0;
-        gedf_res->blocked = 0;
+        memset(gedf_task_res, 0, sizeof(struct gedf_task_reservation));
+        init_ext_reservation(&gedf_task_res->gedf_res.res, task->pid, &gedf_task_ops);
 
         gedf_task_res->task = task;
         tsk_rt(task)->plugin_state = gedf_task_res;
@@ -328,20 +326,12 @@ long alloc_gedf_container_reservation(
         lt_t relative_deadline)
 {
         struct gedf_container_reservation* gedf_cont_res;
-        struct gedf_reservation* gedf_res;
         gedf_cont_res = kzalloc(sizeof(*gedf_cont_res), GFP_KERNEL);
         if (!gedf_cont_res)
                 return -ENOMEM;
-        gedf_res = &gedf_cont_res->gedf_res;
 
-        init_ext_reservation(&gedf_res->res);
-        gedf_res->res.id = id;
-        gedf_res->res.ops = &gedf_cont_ops;
-
-        gedf_res->linked_on = NULL;
-        gedf_res->scheduled_on = NULL;
-        gedf_res->will_remove = 0;
-        gedf_res->blocked = 0;
+        memset(gedf_cont_res, 0, sizeof(struct gedf_container_reservation));
+        init_ext_reservation(&gedf_cont_res->gedf_res.res, id, &gedf_cont_ops);
 
         gedf_cont_res->max_budget = max_budget;
         gedf_cont_res->period = period;
@@ -361,11 +351,15 @@ static void gedf_env_shutdown(
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
+
         suspend_releases(&gedf_env->domain);
+
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
+        /* cancel all budget tracking hrtimers */
         for_each_online_cpu(i) {
                 hrtimer_cancel(&gedf_env->cpu_entries[i].timer);
         }
+        /* call shutdown on all scheduled reservations */
         while (!list_empty(&gedf_env->all_reservations)) {
                 res = list_first_entry(&gedf_env->all_reservations,
                                         struct reservation, all_list);
@@ -373,6 +367,8 @@ static void gedf_env_shutdown(
                 res->ops->shutdown(res);
         }
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
+
+        /* free memory */
         kfree(env);
 }
 
@@ -389,13 +385,14 @@ static void gedf_env_remove_res(
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         gedf_res = container_of(res, struct gedf_reservation, res);
+
         gedf_res->will_remove = complete;
         gedf_res->blocked = !complete;
+
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
         list_del_init(&gedf_res->res.all_list);
-        unlink(gedf_res, gedf_env);
-        if (gedf_res->scheduled_on)
-                preempt(gedf_res->scheduled_on);
+        unlink(gedf_env, gedf_res);
+        check_for_preemptions(gedf_env);
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
         /* After preempt is called, schedule will update budget tracking.
          * In update_time, the environment will detect that res(which is scheduled)
@@ -414,114 +411,124 @@ static void gedf_env_add_res(
         struct gedf_reservation_environment* gedf_env;
         struct gedf_reservation* gedf_res;
         unsigned long flags;
+
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         gedf_res = container_of(res, struct gedf_reservation, res);
+
         res->par_env = env;
         gedf_res->will_remove = 0;
         gedf_res->blocked = 0;
 
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
         list_add(&gedf_res->res.all_list, &gedf_env->all_reservations);
-        requeue(&gedf_env->domain, res);
+        requeue(gedf_env, gedf_res);
         check_for_preemptions(gedf_env);
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
 }
 
+/* TODO: currently does not fully support dynamic cores count in environment
+ * when a core is suspended, if the release timer is on that core, it will not be
+ * properly suspended. Only the last core to suspend stops the release timer
+ */
 static void gedf_env_suspend(
         struct reservation_environment* env,
         int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
         struct cpu_entry* entry;
-        int env_cpu;
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
-        env_cpu = gedf_env->cpu_mapping[cpu];
-        entry = &gedf_env->cpu_entries[env_cpu];
-
-        if (env_cpu == 0)
-                suspend_releases(&gedf_env->domain);
+        entry = &gedf_env->cpu_entries[cpu];
 
-        /* this essentially removes the cpu from scheduling consideration */
-        /*
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
+
+        gedf_env->num_cpus--;
+        /* on env suspension, we need to preempt scheduled tasks, and unlink linked tasks */
         if (entry->linked) {
-                unlink(entry->linked, gedf_env);
-                requeue(entry->linked);
+                unlink(gedf_env, entry->linked);
+                requeue(gedf_env, entry->linked);
         }
+        if (entry->scheduled && entry->scheduled->res.ops->on_preempt)
+                entry->scheduled->res.ops->on_preempt(&entry->scheduled->res, cpu);
+
+        /* this essentially removes the cpu from scheduling consideration */
         bheap_delete(cpu_lower_prio, &gedf_env->cpu_heap, entry->hn);
+
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
-        */
+
+        /* suspends rt_domain releases when the last core of env is preempted */
+        if (!gedf_env->num_cpus)
+                suspend_releases(&gedf_env->domain);
 
         hrtimer_try_to_cancel(&entry->timer);
 }
 
 static void gedf_env_resume(
         struct reservation_environment* env,
-        lt_t now,
         int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
         struct cpu_entry* entry;
-        int env_cpu;
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
-        env_cpu = gedf_env->cpu_mapping[cpu];
-        entry = &gedf_env->cpu_entries[env_cpu];
+        entry = &gedf_env->cpu_entries[cpu];
 
-        if (env_cpu == 0)
+        /* resumes rt_domain releases when the first core of env resumes execution */
+        if (!gedf_env->num_cpus)
                 resume_releases(&gedf_env->domain);
 
-        /* adds cpu back to scheduling consideration */
-        /*
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
-        bheap_insert(cpu_lower_prio, cpu_heap, entry->hn);
-        raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
-        */
 
-        if (entry->scheduled)
-                hrtimer_start(
-                        &entry->timer,
-                        ns_to_ktime(litmus_clock() + entry->scheduled->cur_budget),
-                        HRTIMER_MODE_ABS_PINNED);
+        gedf_env->num_cpus++;
+        /* adds cpu back to scheduling consideration */
+        bheap_insert(cpu_lower_prio, &gedf_env->cpu_heap, entry->hn);
+
+        raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
 }
 
 static struct task_struct* gedf_env_dispatch(
         struct reservation_environment* env,
-        lt_t now,
         int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
         struct cpu_entry* entry;
-        int env_cpu;
         struct task_struct* next = NULL;
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
-        env_cpu = gedf_env->cpu_mapping[cpu];
-        entry = &gedf_env->cpu_entries[env_cpu];
+        entry = &gedf_env->cpu_entries[cpu];
+
+        BUG_ON(!bheap_node_in_heap(entry->hn));
+        BUG_ON(entry->id != cpu);
 
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
 
-        check_for_preemptions(gedf_env);
+        /* update linked if linked for this cpu is empty */
+        if (!entry->linked)
+                check_for_preemptions(gedf_env);
+
+        /* if linked and scheduled differ, preempt and schedule accordingly */
         if (entry->scheduled != entry->linked) {
-                if (entry->scheduled && entry->scheduled->ops->on_preempt)
-                        entry->scheduled->ops->on_preempt(entry->scheduled, cpu);
-                if (entry->linked && entry->linked->ops->on_schedule)
-                        entry->linked->ops->on_schedule(entry->linked, now, cpu);
+                if (entry->scheduled && entry->scheduled->res.ops->on_preempt)
+                        entry->scheduled->res.ops->on_preempt(&entry->scheduled->res, cpu);
+                if (entry->linked && entry->linked->res.ops->on_schedule)
+                        entry->linked->res.ops->on_schedule(&entry->linked->res, cpu);
                 entry->scheduled = entry->linked;
         }
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
 
         //TODO: Think about possible problems with entry->scheduled being changed
         if (entry->scheduled) {
-                next = entry->scheduled->ops->dispatch_client(entry->scheduled, now, cpu);
+                /* let scheduled reservation decide what runs next */
+                next = entry->scheduled->res.ops->dispatch_client(&entry->scheduled->res, cpu);
+                /* set timer for budget expiration */
                 hrtimer_start(&entry->timer,
                         ns_to_ktime(litmus_clock() + entry->scheduled->cur_budget),
                         HRTIMER_MODE_ABS_PINNED);
         }
+        /* cancel budget timer when no reservation is set to be scheduled */
         else
                 hrtimer_try_to_cancel(&entry->timer);
 
@@ -529,43 +536,45 @@ static struct task_struct* gedf_env_dispatch(
 }
 
 static void gedf_env_update_time(
-        struct reservation_environment* env, lt_t how_much, int cpu)
+        struct reservation_environment* env,
+        lt_t how_much,
+        int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
-        struct gedf_reservation* gedf_res;
         struct cpu_entry* entry;
-        int env_cpu;
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
-        env_cpu = gedf_env->cpu_mapping[cpu];
-        entry = &gedf_env->cpu_entries[env_cpu];
+        entry = &gedf_env->cpu_entries[cpu];
 
+        BUG_ON(!bheap_node_in_heap(entry->hn));
         BUG_ON(entry->id != cpu);
 
         if (!entry->scheduled)
                 return;
 
-        entry->scheduled->ops->drain_budget(entry->scheduled, how_much, cpu);
-        gedf_res = container_of(entry->scheduled, struct gedf_reservation, res);
+        /* tells scheduled res to drain its budget */
+        entry->scheduled->res.ops->drain_budget(&entry->scheduled->res, how_much, cpu);
+
         /* if flagged for removal from environment, invoke shutdown callback */
-        if (gedf_res->will_remove) {
+        if (entry->scheduled->will_remove) {
                 /* assumed to already been unlinked by whatever set will_remove */
-                entry->scheduled->ops->shutdown(entry->scheduled);
+                entry->scheduled->res.ops->shutdown(&entry->scheduled->res);
                 entry->scheduled = NULL;
         } else if (!entry->scheduled->cur_budget) {
-                entry->scheduled->ops->replenish_budget(entry->scheduled, cpu);
+                entry->scheduled->res.ops->replenish_budget(&entry->scheduled->res, cpu);
                 /* unlink and requeue if not blocked */
-                if (!gedf_res->blocked) {
+                if (!entry->scheduled->blocked) {
                         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
-                        unlink((struct gedf_reservation*)entry->scheduled, gedf_env);
-                        requeue(&gedf_env->domain, entry->scheduled);
+                        unlink(gedf_env, entry->scheduled);
+                        requeue(gedf_env, entry->scheduled);
                         check_for_preemptions(gedf_env);
                         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
                 }
         }
 }
 
+/* callback for how the domain will release jobs */
 static void gedf_env_release_jobs(rt_domain_t* rt, struct bheap* res)
 {
         unsigned long flags;
@@ -590,7 +599,7 @@ static struct reservation_environment_ops gedf_env_ops = {
 
 long alloc_gedf_reservation_environment(
         struct gedf_reservation_environment** _env,
-        int num_cpus)
+        int max_cpus)
 {
         struct gedf_reservation_environment* gedf_env;
         int i;
@@ -600,17 +609,26 @@ long alloc_gedf_reservation_environment(
                 return -ENOMEM;
 
         memset(gedf_env, 0, sizeof(struct gedf_reservation_environment));
+
+        /* set environment callback actions */
         gedf_env->env.ops = &gedf_env_ops;
+
         INIT_LIST_HEAD(&gedf_env->all_reservations);
         gedf_env->num_cpus = 0;
         bheap_init(&gedf_env->cpu_heap);
-        for (i = 0; i < num_cpus; i++) {
-                gedf_env->cpu_entries[i].hn = &gedf_env->cpu_node[i];
+        for (i = 0; i < max_cpus; i++) {
+                gedf_env->cpu_entries[i].id = i;
+
+                /* initialize cpu timer */
                 hrtimer_init(&gedf_env->cpu_entries[i].timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
                 gedf_env->cpu_entries[i].timer.function = timer_callback;
+
+                /* initialize cpu heap node */
+                gedf_env->cpu_entries[i].hn = &gedf_env->cpu_node[i];
                 bheap_node_init(&gedf_env->cpu_entries[i].hn, &gedf_env->cpu_entries[i]);
-                bheap_insert(cpu_lower_prio, &gedf_env->cpu_heap, gedf_env->cpu_entries[i].hn);
         }
+
+        /* initialize environment domain */
         rt_domain_init(&gedf_env->domain, edf_ready_order, NULL, gedf_env_release_jobs);
 
         *_env = gedf_env;
diff --git a/litmus/sched_ext_res.c b/litmus/sched_ext_res.c
index e79986a12b2c..dd2ae0f02fb3 100644
--- a/litmus/sched_ext_res.c
+++ b/litmus/sched_ext_res.c
@@ -66,13 +66,12 @@ static struct task_struct* ext_res_schedule(struct task_struct * prev)
         lt_t now, delta;
         struct task_struct* next;
 
-        now = litmus_clock();
-        delta = now - *this_cpu_ptr(&last_update_time);
+        delta = litmus_clock() - *this_cpu_ptr(&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, now, cpu);
+        next = gedf_env->env.ops->dispatch(&gedf_env->env, cpu);
 
         *this_cpu_ptr(&last_update_time) = litmus_clock();
 
@@ -318,8 +317,8 @@ static long ext_res_activate_plugin(void)
         for_each_online_cpu(cpu) {
                 TRACE("Initializing CPU%d...\n", cpu);
                 *this_cpu_ptr(&last_update_time) = now;
-                gedf_env->cpu_mapping[cpu] = cpu;
                 gedf_env->cpu_entries[cpu].id = cpu;
+                gedf_env->env.ops->resume(&gedf_env->env, cpu);
         }
         gedf_env->num_cpus = num_cpus;