added support for np-sections in GEDF reservation.

Also, includes WIP of component allocator. This WIP is not included in
the makefile so it won't mess up the compilation.

9 files changed, 457 insertions, 102 deletions

diff --git a/include/litmus/reservations/ext_reservation.h b/include/litmus/reservations/ext_reservation.h
index 40c9cd9e098e..97b8bad916df 100644
--- a/include/litmus/reservations/ext_reservation.h
+++ b/include/litmus/reservations/ext_reservation.h
@@ -25,6 +25,7 @@ typedef void (*drain_budget_t) (
 
 typedef struct task_struct* (*dispatch_client_t) (
         struct reservation *reservation,
+        lt_t* time_slice,
         int cpu
 );
 
@@ -40,8 +41,15 @@ typedef void (*on_preempt_t) (
         int cpu
 );
 
+typedef int (*is_np_t) (
+        struct reservation *reservation,
+        int cpu
+);
+
 /* Destructor: called before scheduler is deactivated. */
-typedef void (*shutdown_t)(struct reservation *reservation);
+typedef void (*shutdown_t)(
+        struct reservation *reservation
+);
 
 struct reservation_ops {
         drain_budget_t drain_budget;
@@ -49,6 +57,7 @@ struct reservation_ops {
         dispatch_client_t dispatch_client;
         on_schedule_t on_schedule;
         on_preempt_t on_preempt;
+        is_np_t is_np;
         shutdown_t shutdown;
 };
 
@@ -58,6 +67,7 @@ struct reservation {
         /* exact meaning defined by impl. */
         lt_t priority;
         lt_t replenishment_time;
+        lt_t cur_budget;
 
         /* budget stats */
         lt_t budget_consumed; /* how much budget consumed in this allocation cycle? */
@@ -93,6 +103,7 @@ typedef void (*env_update_time_t) (
 
 typedef struct task_struct* (*env_dispatch_t) (
         struct reservation_environment* env,
+        lt_t* time_slice,
         int cpu);
 
 typedef void (*env_resume_t) (
@@ -103,12 +114,24 @@ typedef void (*env_suspend_t) (
         struct reservation_environment* env,
         int cpu);
 
-typedef void (*env_add_res_t) (struct reservation_environment* env,
-        struct reservation* res);
+typedef void (*env_add_res_t) (
+        struct reservation_environment* env,
+        struct reservation* res,
+        int cpu);
 
-typedef void (*env_remove_res_t) (struct reservation_environment* env,
+typedef void (*env_remove_res_t) (
+        struct reservation_environment* env,
         struct reservation* res,
-        int complete);
+        int complete,
+        int cpu);
+
+typedef struct reservation* (*env_find_res_t) (
+        struct reservation_environment* env,
+        int id);
+
+typedef int (*env_is_np_t) (
+        struct reservation_environment* env,
+        int cpu);
 
 typedef void (*env_shutdown_t) (
         struct reservation_environment* env);
@@ -120,12 +143,15 @@ struct reservation_environment_ops {
         env_suspend_t           suspend;
         env_add_res_t           add_res;
         env_remove_res_t        remove_res;
+        env_find_res_t          find_res_by_id;
+        env_is_np_t                     is_np;
         env_shutdown_t          shutdown;
 };
 
 struct reservation_environment {
         struct reservation_environment_ops* ops;
         struct reservation* res;
+        struct list_head all_reservations;
 };
 
 static inline void env_to_res_couple(
diff --git a/include/litmus/reservations/gedf_reservation.h b/include/litmus/reservations/gedf_reservation.h
index 2adaaabbcaf4..e39d632262a3 100644
--- a/include/litmus/reservations/gedf_reservation.h
+++ b/include/litmus/reservations/gedf_reservation.h
@@ -10,15 +10,14 @@
 /* ************************************************************************** */
 struct gedf_reservation {
         struct reservation res;
-        struct cpu_entry* linked_on;
+        struct gedf_cpu_entry* linked_on;
         lt_t cur_budget;
         int will_remove;
         int blocked;
 };
 
-struct cpu_entry {
+struct gedf_cpu_entry {
         int id;
-        struct hrtimer timer;
         struct bheap_node* hn;
         struct gedf_reservation* linked;
         struct gedf_reservation* scheduled;
@@ -60,7 +59,7 @@ struct gedf_reservation_environment {
         volatile int num_cpus;
 
         /* array of gedf cpu entries */
-        struct cpu_entry cpu_entries[NR_CPUS];
+        struct gedf_cpu_entry cpu_entries[NR_CPUS];
 
         /* used to order cpus for gedf purposes */
         struct bheap cpu_heap;
diff --git a/include/litmus/reservations/table_driven_ext_reservation.h b/include/litmus/reservations/table_driven_ext_reservation.h
index 51c32eadb419..100b4eea8cba 100644
--- a/include/litmus/reservations/table_driven_ext_reservation.h
+++ b/include/litmus/reservations/table_driven_ext_reservation.h
@@ -4,22 +4,14 @@
 #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 mtd_reservation {
         struct reservation res;
+        volatile int in_env;
         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;
 };
@@ -29,15 +21,22 @@ long alloc_mtd_reservation(
         struct reservation** _res
 );
 
+struct mtd_cpu_entry {
+        int id;
+        struct hrtimer timer;
+        lt_t cur_time;
+        mtd_reservation* scheduled;
+        rt_domain_t domain;
+}
+
 /* environment for scheduling reservations via gedf */
-struct td_reservation_environment {
+struct mtd_reservation_environment {
         struct reservation_environment env;
+
         /* number of active cpus in reservation */
         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;
diff --git a/include/litmus/rt_domain.h b/include/litmus/rt_domain.h
index 0fabd7e6ea55..45dfb1e2b76f 100644
--- a/include/litmus/rt_domain.h
+++ b/include/litmus/rt_domain.h
@@ -67,8 +67,11 @@ struct release_heap {
         struct list_head                list_head;
 };
 
-void suspend_releases(rt_domain_t* rt);
-void resume_releases(rt_domain_t* rt);
+/* used to manually release jobs */
+void release_jobs_before_now(rt_domain_t* rt);
+
+void domain_suspend_releases(rt_domain_t* rt);
+void domain_resume_releases(rt_domain_t* rt);
 
 static inline struct task_struct* __next_ready(rt_domain_t* rt)
 {
diff --git a/litmus/reservations/Makefile b/litmus/reservations/Makefile
index fcb3685ae72e..cda2b1605e65 100644
--- a/litmus/reservations/Makefile
+++ b/litmus/reservations/Makefile
@@ -4,4 +4,3 @@ obj-y += table-driven.o
 
 obj-y += ext_reservation.o
 obj-y += gedf_reservation.o
-obj-y += task_reservation.o
diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index aa5eb9d4b821..2b0d37b4d52c 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -8,6 +8,7 @@
 #include <litmus/bheap.h>
 #include <litmus/rt_domain.h>
 #include <litmus/jobs.h>
+#include <litmus/np.h>
 #include <litmus/sched_trace.h>
 #include <litmus/debug_trace.h>
 #include <litmus/reservations/gedf_reservation.h>
@@ -55,21 +56,21 @@ static int edf_ready_order(struct bheap_node* a, struct bheap_node* b)
  */
 static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
 {
-        struct cpu_entry *a, *b;
+        struct gedf_cpu_entry *a, *b;
         a = _a->value;
         b = _b->value;
         /* use higher prio here because prio is deadline value */
         return higher_prio(&a->linked->res, &b->linked->res);
 }
 
-static void update_cpu_position(struct cpu_entry* entry, struct bheap* cpu_heap)
+static void update_cpu_position(struct gedf_cpu_entry* entry, struct bheap* cpu_heap)
 {
         if (likely(bheap_node_in_heap(entry->hn)))
                 bheap_delete(cpu_lower_prio, cpu_heap, entry->hn);
         bheap_insert(cpu_lower_prio, cpu_heap, entry->hn);
 }
 
-static struct cpu_entry* lowest_prio_cpu(struct bheap* cpu_heap)
+static struct gedf_cpu_entry* lowest_prio_cpu(struct bheap* cpu_heap)
 {
         struct bheap_node* hn;
         hn = bheap_peek(cpu_lower_prio, cpu_heap);
@@ -98,15 +99,10 @@ static int edf_preemption_needed(
 
 /* ******************************************************************************** */
 //TODO: add support for checking non-preemptivity
-static void preempt(struct cpu_entry* entry)
+static void preempt(struct gedf_cpu_entry* entry)
 {
-        litmus_reschedule(entry->id);
-}
-
-static enum hrtimer_restart timer_callback(struct hrtimer* timer)
-{
-        litmus_reschedule_local();
-        return HRTIMER_NORESTART;
+        if (!entry->scheduled || entry->scheduled->res.ops->is_np(&entry->scheduled->res, entry->id))
+                litmus_reschedule(entry->id);
 }
 
 static void requeue(
@@ -126,7 +122,7 @@ static void requeue(
 static void link_task_to_cpu(
         struct gedf_reservation_environment* gedf_env,
         struct gedf_reservation* linked,
-        struct cpu_entry* entry)
+        struct gedf_cpu_entry* entry)
 {
 
         if (entry->linked)
@@ -155,13 +151,13 @@ static void unlink(
 static void check_for_preemptions(struct gedf_reservation_environment* gedf_env)
 {
         struct gedf_reservation* gedf_res;
-        struct cpu_entry* last;
+        struct gedf_cpu_entry* last;
 
         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)
+                if (last->linked && last->linked->res.cur_budget)
                         requeue(gedf_env, last->linked);
                 link_task_to_cpu(gedf_env, gedf_res, last);
                 preempt(last);
@@ -177,6 +173,27 @@ static void gedf_shutdown(
         kfree(res);
 }
 
+static int gedf_is_np(
+        struct reservation *res,
+        int cpu)
+{
+        return res->env->ops->is_np(res->env, cpu);
+}
+
+static int gedf_task_is_np(
+        struct reservation *res,
+        int cpu)
+{
+        struct task_struct* t = ((struct gedf_task_reservation*)res)->task;
+        if (is_user_np(t)) {
+                request_exit_np(t);
+                return 1;
+        } else if (is_kernel_np(t))
+                return 1;
+
+        return 0;
+}
+
 static void gedf_task_shutdown(
         struct reservation *res)
 {
@@ -200,13 +217,15 @@ static void gedf_on_schedule(
 
 static struct task_struct* gedf_dispatch_client(
         struct reservation* res,
+        lt_t* time_slice,
         int cpu)
 {
-        return res->env->ops->dispatch(res->env, cpu);
+        return res->env->ops->dispatch(res->env, time_slice, cpu);
 }
 
 static struct task_struct* gedf_task_dispatch_client(
         struct reservation* res,
+        lt_t* time_slice,
         int cpu)
 {
         return ((struct gedf_task_reservation*)res)->task;
@@ -219,7 +238,7 @@ static void gedf_replenish_budget(
         struct gedf_container_reservation* gedf_cont_res =
                 (struct gedf_container_reservation*)res;
         res->budget_consumed = 0;
-        gedf_cont_res->gedf_res.cur_budget = gedf_cont_res->max_budget;
+        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;
 }
@@ -229,7 +248,6 @@ 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);
@@ -245,7 +263,7 @@ static void gedf_task_replenish_budget(
                 TRACE_TASK(t, "overrun budget!\n");
         }
         res->budget_consumed = 0;
-        gedf_res->cur_budget = get_exec_cost(t);
+        res->cur_budget = get_exec_cost(t);
 }
 
 static void gedf_drain_budget(
@@ -253,12 +271,10 @@ static void gedf_drain_budget(
         lt_t how_much,
         int cpu)
 {
-        struct gedf_reservation* gedf_res = container_of(res, struct gedf_reservation, res);
-
-        if (how_much > gedf_res->cur_budget)
-                gedf_res->cur_budget = 0;
+        if (how_much > res->cur_budget)
+                res->cur_budget = 0;
         else
-                gedf_res->cur_budget -= how_much;
+                res->cur_budget -= how_much;
         res->budget_consumed += how_much;
         res->budget_consumed_total += how_much;
 
@@ -271,12 +287,11 @@ static void gedf_task_drain_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 (how_much > gedf_res->cur_budget || is_completed(t))
-                gedf_res->cur_budget = 0;
+        if (how_much > res->cur_budget || is_completed(t))
+                res->cur_budget = 0;
         else
-                gedf_res->cur_budget -= how_much;
+                res->cur_budget -= how_much;
         res->budget_consumed += how_much;
         res->budget_consumed_total += how_much;
 }
@@ -288,6 +303,7 @@ static struct reservation_ops gedf_cont_ops =
         .dispatch_client = gedf_dispatch_client,
         .on_schedule = gedf_on_schedule,
         .on_preempt = gedf_on_preempt,
+        .is_np = gedf_is_np,
         .shutdown = gedf_shutdown
 };
 
@@ -296,6 +312,7 @@ static struct reservation_ops gedf_task_ops =
         .drain_budget = gedf_task_drain_budget,
         .replenish_budget = gedf_task_replenish_budget,
         .dispatch_client = gedf_task_dispatch_client,
+        .is_np = gedf_task_is_np,
         .shutdown = gedf_task_shutdown
 };
 
@@ -347,21 +364,17 @@ static void gedf_env_shutdown(
 {
         struct gedf_reservation_environment* gedf_env;
         struct reservation* res;
-        int i;
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
 
-        suspend_releases(&gedf_env->domain);
+        domain_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,
+        while (!list_empty(&env->all_reservations)) {
+                res = list_first_entry(&env->all_reservations,
                                         struct reservation, all_list);
                 list_del(&res->all_list);
                 res->ops->shutdown(res);
@@ -372,12 +385,37 @@ static void gedf_env_shutdown(
         kfree(env);
 }
 
+static int gedf_env_is_np(
+        struct reservation_environment* env,
+        int cpu)
+{
+        struct gedf_reservation_environment* gedf_env =
+                container_of(env, struct gedf_reservation_environment, env);
+        struct reservation* res =
+                &gedf_env->cpu_entries[cpu].scheduled->res;
+        return res->ops->is_np(res, cpu);
+}
+
+static struct reservation* gedf_find_res_by_id(
+        struct reservation_environment* env,
+        int id)
+{
+        struct reservation* res;
+        list_for_each_entry(res, &env->all_reservations, all_list) {
+                if (res->id == id)
+                        return res;
+        }
+        return NULL;
+}
+
 /* This assumes that is is only called from res itself requesting to be removed
+ * This WILL cause rt task to become lost if res is a scheduling entity
  */
 static void gedf_env_remove_res(
         struct reservation_environment* env,
         struct reservation* res,
-        int complete)
+        int complete,
+        int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
         struct gedf_reservation* gedf_res;
@@ -406,7 +444,8 @@ static void gedf_env_remove_res(
 
 static void gedf_env_add_res(
         struct reservation_environment* env,
-        struct reservation* res)
+        struct reservation* res,
+        int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
         struct gedf_reservation* gedf_res;
@@ -420,7 +459,7 @@ static void gedf_env_add_res(
         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);
+        list_add_tail(&gedf_res->res.all_list, &env->all_reservations);
         requeue(gedf_env, gedf_res);
         check_for_preemptions(gedf_env);
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
@@ -435,7 +474,7 @@ static void gedf_env_suspend(
         int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
-        struct cpu_entry* entry;
+        struct gedf_cpu_entry* entry;
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
@@ -443,6 +482,9 @@ static void gedf_env_suspend(
 
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
 
+        //TODO: More Graceful way to handle forbidden zone violation?
+        BUG_ON(env->ops->is_np(env, cpu));
+
         gedf_env->num_cpus--;
         /* on env suspension, we need to preempt scheduled tasks, and unlink linked tasks */
         if (entry->linked) {
@@ -459,9 +501,7 @@ static void gedf_env_suspend(
 
         /* 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);
+                domain_suspend_releases(&gedf_env->domain);
 }
 
 static void gedf_env_resume(
@@ -469,7 +509,7 @@ static void gedf_env_resume(
         int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
-        struct cpu_entry* entry;
+        struct gedf_cpu_entry* entry;
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
@@ -477,7 +517,7 @@ static void gedf_env_resume(
 
         /* resumes rt_domain releases when the first core of env resumes execution */
         if (!gedf_env->num_cpus)
-                resume_releases(&gedf_env->domain);
+                domain_resume_releases(&gedf_env->domain);
 
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
 
@@ -490,12 +530,14 @@ static void gedf_env_resume(
 
 static struct task_struct* gedf_env_dispatch(
         struct reservation_environment* env,
+        lt_t* time_slice,
         int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
-        struct cpu_entry* entry;
+        struct gedf_cpu_entry* entry;
         struct task_struct* next = NULL;
         unsigned long flags;
+        int np = 0;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         entry = &gedf_env->cpu_entries[cpu];
@@ -503,14 +545,18 @@ static struct task_struct* gedf_env_dispatch(
         BUG_ON(!bheap_node_in_heap(entry->hn));
         BUG_ON(entry->id != cpu);
 
+        if (entry->scheduled)
+                np = entry->scheduled->res.ops->is_np(&entry->scheduled->res, cpu);
+
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
 
+
         /* 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 (!np && entry->scheduled != entry->linked) {
                 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)
@@ -519,18 +565,14 @@ static struct task_struct* gedf_env_dispatch(
         }
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
 
-        //TODO: Think about possible problems with entry->scheduled being changed
         if (entry->scheduled) {
                 /* 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);
+                next = entry->scheduled->res.ops->dispatch_client(&entry->scheduled->res, time_slice, cpu);
+                *time_slice = (*time_slice > entry->scheduled->res.cur_budget) ?
+                        entry->scheduled->res.cur_budget : *time_slice;
+        } else {
+                *time_slice = ULLONG_MAX;
         }
-        /* cancel budget timer when no reservation is set to be scheduled */
-        else
-                hrtimer_try_to_cancel(&entry->timer);
 
         return next;
 }
@@ -541,7 +583,7 @@ static void gedf_env_update_time(
         int cpu)
 {
         struct gedf_reservation_environment* gedf_env;
-        struct cpu_entry* entry;
+        struct gedf_cpu_entry* entry;
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
@@ -561,10 +603,11 @@ static void gedf_env_update_time(
                 /* assumed to already been unlinked by whatever set will_remove */
                 entry->scheduled->res.ops->shutdown(&entry->scheduled->res);
                 entry->scheduled = NULL;
-        } else if (!entry->scheduled->cur_budget) {
+        } else if (!entry->scheduled->res.cur_budget) {
                 entry->scheduled->res.ops->replenish_budget(&entry->scheduled->res, cpu);
-                /* unlink and requeue if not blocked */
-                if (!entry->scheduled->blocked) {
+                /* unlink and requeue if not blocked and not np*/
+                if (!entry->scheduled->blocked &&
+                                !entry->scheduled->res.ops->is_np(&entry->scheduled->res, cpu)) {
                         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
                         unlink(gedf_env, entry->scheduled);
                         requeue(gedf_env, entry->scheduled);
@@ -594,6 +637,8 @@ static struct reservation_environment_ops gedf_env_ops = {
         .suspend = gedf_env_suspend,
         .add_res = gedf_env_add_res,
         .remove_res = gedf_env_remove_res,
+        .find_res_by_id = gedf_find_res_by_id,
+        .is_np = gedf_env_is_np,
         .shutdown = gedf_env_shutdown
 };
 
@@ -612,17 +657,13 @@ long alloc_gedf_reservation_environment(
 
         /* set environment callback actions */
         gedf_env->env.ops = &gedf_env_ops;
+        INIT_LIST_HEAD(&gedf_env->env.all_reservations);
 
-        INIT_LIST_HEAD(&gedf_env->all_reservations);
         gedf_env->num_cpus = 0;
         bheap_init(&gedf_env->cpu_heap);
         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]);
diff --git a/litmus/reservations/table_driven_ext_reservation.c b/litmus/reservations/table_driven_ext_reservation.c
new file mode 100644
index 000000000000..ba633f2d5be6
--- /dev/null
+++ b/litmus/reservations/table_driven_ext_reservation.c
@@ -0,0 +1,256 @@
+static task_struct* mtd_dispatch_client(
+        struct reservation* res,
+        lt_t now,
+        int cpu)
+{
+        res->env->ops->dispatch(res->env, now, cpu);
+}
+
+static void mtd_replenish_budget(
+        struct reservation* res,
+        int cpu)
+{
+        struct mtd_reservation* mtd_res =
+                container_of(res, struct mtd_reservation, res);
+
+        mtd_res->interval_index[cpu] = mtd_res->interval_index[cpu]
+
+        res->replenishment_time = mtd_res = mtd_res->major_cycple_start;
+        res->replenishment_time += mtd_tres->intervals[cpu][mtd_res->next_interval[cpu]];
+
+        res->cur_interval[cpu].start = intervals[cpu][interval_index[cpu]].start;
+        res->cur_interval[cpu].end = intervals[cpu][interval_index[cpu]].end;
+}
+
+static void mtd_drain_budget(
+        struct reservation* res,
+        lt_t how_much,
+        int cpu)
+{
+        struct mtd_reservation* mtd_res;
+        lt_t now, end;
+
+        mtd_res = container_of(res, struct mtd_reservation, res[cpu]);
+
+        BUG_ON(res != &mtd_res->res[cpu]);
+
+        now = litmus_clock();
+        end = mtd_res->cur_interval.end;
+        if (now >= end)
+                res->cur_budget = 0;
+        else
+                res->cur_budget = end - now;
+
+        res->env->ops->update_time(res->env, how_much, cpu);
+}
+
+static struct reservation_ops mtd_ops = {
+        .drain_budget = asdf,
+};
+
+long alloc_mtd_reservation(
+        struct reservation** _res,
+        unsigned int id,
+        lt_t major_cycle)
+{
+        struct mtd_reservation* mtd_res;
+        unsigned int num_slots, id;
+        int cpu;
+
+        mtd_res = kzalloc(sizeof(struct mtd_reservation), GFP_KERNEL);
+        if (!mtd_res)
+                return -ENOMEM;
+        init_ext_reservation(&mtd_res->res, id, mtd_ops);
+        mtd_res->major_cycle = major_cycle;
+}
+
+/* ***************************************************************** */
+static void requeue(
+        struct mtd_cpu_entry entry,
+        struct mtd_reservation* mtd_res)
+{
+        BUG_ON(!mtd_res);
+        BUG_ON(is_queued_res(&mtd_res->res));
+
+        if (lt_before_eq(mtd_res->res.replenishment_time, litmus_clock()))
+                __add_ready_res(&entry->domain, &mtd_res->res);
+        else
+                __add_release_res_no_timer(&entry->domain, &mtd_res->res);
+
+}
+
+/* ***************************************************************** */
+static void mtd_env_shutdown(
+        struct reservation_environment* env)
+{
+        struct mtd_reservation_environment* gedf_env;
+        struct reservation* res;
+        unsigned long flags;
+        int cpu;
+
+        mtd_env = container_of(env, struct mtd_reservation_environment, env);
+
+        for_each_online_cpu(cpu) {
+                domain_suspend_releases(&mtd_env->cpu_entry[cpu]->domain);
+        }
+
+        raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
+
+        /* call shutdown on all scheduled reservations */
+        while (!list_empty(&env->all_reservations)) {
+                res = list_first_entry(&env->all_reservations,
+                                        struct reservation, all_list);
+                list_del(&res->all_list);
+                res->ops->shutdown(res);
+        }
+        raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
+
+        /* free memory */
+        kfree(env);
+}
+
+static struct reservation* mtd_find_res_by_id(
+        struct reservation_environment* env,
+        int id)
+{
+        struct reservation* res;
+        list_for_each_entry(res, &env->all_reservations, all_list) {
+                if (res->id == id)
+                        return res;
+        }
+}
+
+/* not supported */
+static void mtd_env_remove_res(
+        struct reservation_environment* env,
+        struct reservation* res,
+        int complete,
+        int cpu)
+{
+        return;
+}
+
+/* the reservation is added one core at a time due to how the table is specified */
+static void mtd_env_add_res(
+        struct reservation_environment* env,
+        struct reservation* res,
+        int cpu)
+{
+        struct mtd_reservation_environment* mtd_env;
+        struct mtd_reservation* mtd_res;
+        lt_t tmp;
+
+        mtd_res->in_env++;
+        if (mtd_res->in_env == 1) {
+                list_add_tail(&mtd_res->res[0].all_list, &env->all_reservations);
+        }
+
+        tmp = div64_u64(now, mtd_res->major_cycle);
+        mtd_res->major_cycle_start = tmp * mtd_res->major_cycle;
+
+        if (mtd_res->num_intervals[cpu]) {
+                tmp = mtd_res->major_cycle_start;
+                res->replenishment_time = tmp + mtd_res->cur_interval.start;
+
+                raw_spin_lock_irqsave(&mtd_env->cpu_entries[cpu]->timer, flags);
+                requeue(&mtd_env->cpu_entries[cpu], &mtd_res->res[cpu]);
+                if (mtd_res->res[cpu].replenish_time <= litmus_clock())
+                        litmus_reschedule_local();
+                raw_spin_unlock_irqrestore(&mtd_env->cpu_entries[cpu]->timer, flags);
+        }
+}
+
+/* not supported */
+static void mtd_env_suspend(
+        struct reservation_environment* env,
+        int cpu)
+{
+        return;
+}
+
+/* not supported */
+static void mtd_env_resume(
+        struct reservation_environment* env,
+        int cpu)
+{
+        return;
+}
+
+/* If two reservations have overlapping intervals on the same core,
+ * then which one is scheduled is undefined
+ */
+static struct task_struct* mtd_env_dispatch(
+        struct reservation_environment* env,
+        lt_t* time_slice,
+        int cpu)
+{
+        struct mtd_reservation_environment* mtd_env;
+        struct mtd_cpu_entry* entry;
+        struct mtd_reservation* linked;
+        struct task_struct* next;
+        unsigned long flags;
+        lt_t budget;
+
+        mtd_env = container_of(env, struct mtd_reservation_environment, env);
+        entry = &mtd_env->cpu_entries[cpu];
+
+
+        raw_spin_lock_irqsave(&entry->domain.ready_lock, flags);
+
+        /* if linked and scheduled differ, preempt and schedule accordingly */
+        linked = __peek_ready_res(&entry->domain);
+        if (entry->scheduled != linked) {
+                if (entry->scheduled && entry->scheduled->ops->on_preempt) {
+                        entry->scheduled->ops->on_preempt(entry->scheduled, cpu);
+                }
+                if (linked && linked->ops->on_schedule) {
+                        linked->ops->on_schedule(linked, cpu);
+                }
+                __take_ready_res(&entry->domain);
+                entry->scheduled = linked;
+        }
+        raw_spin_unlock_irqrestore(&entry->domain.ready_lock, flags);
+
+        if (entry->scheduled) {
+                /* let scheduled reservation decide what runs next */
+                next = entry->scheduled->ops->dispatch_client(entry->scheduled, cpu);
+                *time_slice = (*time_slice > entry->scheduled->cur_budget) ?
+                        entry->scheduled->cur_budget : *time_slice;
+        } else
+                *time_slice = ULLONG_MAX;
+
+}
+
+static void mtd_env_update_time(
+        struct reservation_environment* env,
+        lt_t how_much,
+        int cpu)
+{
+        struct mtd_reservation_environment* mtd_env;
+        struct mtd_cpu_entry* entry;
+        struct reservation* res;
+        unsigned long flags;
+
+        mtd_env = container_of(env, struct mtd_reservation_environment, env);
+        entry = &mtd_env->cpu_entries[cpu];
+
+        /* drains budget of ready task */
+        /* In the case that multiple tasks on this core share an execution frame,
+         * only 1 has its budget drained. However, the other tasks will be scheduled
+         * at the end of the frame for epsilon time and immediately have its budget drained
+         * before the task of the next frame is scheduled.
+         * This results in only 1 of the tasks getting actual execution.
+         */
+        if (entry->scheduled) {
+                entry->scheduled->ops->drain_budget(entry->scheduled, how_much, cpu);
+                /* if no more budget, replenish and requeue */
+                if (!entry->scheduled->cur_budget) {
+                        entry->scheduled->ops->replenish_budget(entry->scheduled, cpu);
+                        raw_spin_lock_irqsave(&entry->domain.ready_lock, flags);
+                        requeue(entry, entry->scheduled);
+                        raw_spin_unlock_irqrestore(&entry->domain.ready_lock, flags);
+                }
+        }
+        /* release tasks in domain */
+        release_jobs_before_now(&entry->domain);
+}
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 4c37341065f0..1a15e2491a65 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -62,7 +62,7 @@ int release_order(struct binheap_node *a, struct binheap_node *b)
                                          binheap_entry(b, struct release_heap, node)->release_time);
 }
 
-static void release_jobs_before_now(rt_domain_t* rt)
+void release_jobs_before_now(rt_domain_t* rt)
 {
         unsigned long flags;
         struct release_heap* rh;
@@ -118,12 +118,12 @@ static enum hrtimer_restart on_release_timer(struct hrtimer *timer)
         return HRTIMER_RESTART;
 }
 
-void suspend_releases(rt_domain_t* rt)
+void domain_suspend_releases(rt_domain_t* rt)
 {
-        hrtimer_try_to_cancel(&rt->timer);
+        hrtimer_cancel(&rt->timer);
 }
 
-void resume_releases(rt_domain_t* rt)
+void domain_resume_releases(rt_domain_t* rt)
 {
         release_jobs_before_now(rt);
         if (rt->release_queue.earliest_release != NO_FUTURE_RELEASE) {
diff --git a/litmus/sched_ext_res.c b/litmus/sched_ext_res.c
index dd2ae0f02fb3..63f6d821d2d4 100644
--- a/litmus/sched_ext_res.c
+++ b/litmus/sched_ext_res.c
@@ -18,7 +18,18 @@
 
 struct gedf_reservation_environment* gedf_env;
 
-static DEFINE_PER_CPU(lt_t, last_update_time);
+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)
@@ -63,17 +74,26 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
 static struct task_struct* ext_res_schedule(struct task_struct * prev)
 {
         int cpu = smp_processor_id();
-        lt_t now, delta;
+        lt_t delta, time_slice;
+        struct cpu_time* entry;
         struct task_struct* next;
 
-        delta = litmus_clock() - *this_cpu_ptr(&last_update_time);
+        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, cpu);
+        next = gedf_env->env.ops->dispatch(&gedf_env->env, &time_slice, cpu);
+
+        entry->last_update_time = litmus_clock();
 
-        *this_cpu_ptr(&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();
 
@@ -89,7 +109,7 @@ static void ext_res_task_block(struct task_struct *tsk)
         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);
+        res->par_env->ops->remove_res(res->par_env, res, 0, 0);
 }
 
 
@@ -103,7 +123,7 @@ static void ext_res_task_resume(struct task_struct  *tsk)
         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);
+        res->par_env->ops->add_res(res->par_env, res, 0);
 }
 
 static long ext_res_admit_task(struct task_struct *tsk)
@@ -137,7 +157,7 @@ static void ext_res_task_new(struct task_struct *tsk, int on_runqueue,
         release_at(tsk, now);
         res->replenishment_time = now;
 
-        res->par_env->ops->add_res(res->par_env, res);
+        res->par_env->ops->add_res(res->par_env, res, 0);
 
         if (is_running)
                 litmus_reschedule_local();
@@ -169,7 +189,7 @@ static void ext_res_task_exit(struct task_struct *tsk)
         res = (struct reservation*)tsk_rt(tsk)->plugin_state;
         par_env = res->par_env;
 
-        par_env->ops->remove_res(par_env, res, 1);
+        par_env->ops->remove_res(par_env, res, 1, 0);
 
         TRACE_TASK(tsk, "task exits at %llu \n", litmus_clock());
 }
@@ -310,13 +330,17 @@ static long ext_res_activate_plugin(void)
 {
         int cpu;
         int num_cpus = num_online_cpus();
+        struct cpu_time* entry;
         lt_t now = litmus_clock();
 
         alloc_gedf_reservation_environment(&gedf_env, num_cpus);
 
         for_each_online_cpu(cpu) {
                 TRACE("Initializing CPU%d...\n", cpu);
-                *this_cpu_ptr(&last_update_time) = now;
+                entry = per_cpu_ptr(&cpu_time, cpu);
+                hrtimer_init(&entry->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+                entry->timer.function = on_budget_timeout;
+                entry->last_update_time = now;
                 gedf_env->cpu_entries[cpu].id = cpu;
                 gedf_env->env.ops->resume(&gedf_env->env, cpu);
         }
@@ -329,8 +353,16 @@ static long ext_res_activate_plugin(void)
 
 static long ext_res_deactivate_plugin(void)
 {
+        int cpu;
+        struct cpu_time* entry;
+
         gedf_env->env.ops->shutdown(&gedf_env->env);
 
+        for_each_online_cpu(cpu) {
+                entry = per_cpu_ptr(&cpu_time, cpu);
+                hrtimer_cancel(&entry->timer);
+        }
+
         destroy_domain_proc_info(&ext_res_domain_proc_info);
         return 0;
 }