Checkpoint1(Updated)

Encounters problem where task waits an extra period due to
sleep(unresolved)

9 files changed, 183 insertions, 201 deletions

diff --git a/arch/x86/boot/initrd.img b/arch/x86/boot/initrd.img
new file mode 100644
index 000000000000..239454fce731
--- /dev/null
+++ b/arch/x86/boot/initrd.img
diff --git a/include/litmus/reservations/ext_reservation.h b/include/litmus/reservations/ext_reservation.h
index 7ec326bd14bd..68784f71a268 100644
--- a/include/litmus/reservations/ext_reservation.h
+++ b/include/litmus/reservations/ext_reservation.h
@@ -23,6 +23,12 @@ typedef void (*drain_budget_t) (
         int cpu
 );
 
+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,
@@ -42,6 +48,7 @@ typedef void (*shutdown_t)(struct reservation *reservation);
 struct reservation_ops {
         drain_budget_t drain_budget;
         replenish_budget_t replenish_budget;
+        dispatch_client_t dispatch_client;
         on_schedule_t on_schedule;
         on_preempt_t on_preempt;
         shutdown_t shutdown;
@@ -53,7 +60,7 @@ struct reservation {
         /* exact meaning defined by impl. */
         lt_t priority;
         lt_t cur_budget;
-        lt_t next_replenishment;
+        lt_t replenishment_time;
 
         /* budget stats */
         lt_t budget_consumed; /* how much budget consumed in this allocation cycle? */
diff --git a/include/litmus/reservations/gedf_reservation.h b/include/litmus/reservations/gedf_reservation.h
index e2a4a3dc5968..57f2fa7f00fc 100644
--- a/include/litmus/reservations/gedf_reservation.h
+++ b/include/litmus/reservations/gedf_reservation.h
@@ -22,19 +22,33 @@ struct gedf_reservation {
         struct cpu_entry* scheduled_on;
         int will_remove;
         int blocked;
+};
+
+struct gedf_task_reservation {
+        struct gedf_reservation gedf_res;
+        struct task_struct* task;
+};
+
+struct gedf_container_reservation {
+        struct gedf_reservation gedf_res;
+        lt_t max_budget;
         lt_t period;
         lt_t relative_deadline;
-        lt_t exec_cost;
 };
 
-long alloc_gedf_reservation(
-        struct gedf_reservation** _res,
+long alloc_gedf_container_reservation(
+        struct gedf_container_reservation** _res,
         int id,
-        lt_t exec_cost,
+        lt_t max_budget,
         lt_t period,
         lt_t relative_deadline
 );
 
+long alloc_gedf_task_reservation(
+        struct gedf_task_reservation** _res,
+        struct task_struct* task
+);
+
 /* environment for scheduling reservations via gedf */
 struct gedf_reservation_environment {
         struct reservation_environment env;
diff --git a/include/litmus/reservations/task_reservation.h b/include/litmus/reservations/task_reservation.h
deleted file mode 100644
index 0e0ef74591b6..000000000000
--- a/include/litmus/reservations/task_reservation.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef LITMUS_TASK_RESERVATION_H
-#define LITMUS_TASK_RESERVATION_H
-
-#include <litmus/reservations/ext_reservation.h>
-
-struct task_reservation_environment {
-        struct reservation_environment env;
-        struct task_struct* task;
-};
-
-long alloc_task_reservation_environment(
-        struct task_reservation_environment** _env,
-        struct task_struct* task
-);
-
-#endif
diff --git a/litmus/reservations/ext_reservation.c b/litmus/reservations/ext_reservation.c
index 9623ec520e98..9397241faf99 100644
--- a/litmus/reservations/ext_reservation.c
+++ b/litmus/reservations/ext_reservation.c
@@ -1,4 +1,5 @@
 #include <linux/slab.h>
+#include <litmus/bheap.h>
 #include <litmus/reservations/ext_reservation.h>
 
 /* allocated in litmus.c */
@@ -10,6 +11,7 @@ void init_ext_reservation(struct reservation* res)
         memset(res, 0, sizeof(struct reservation));
         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);
         INIT_LIST_HEAD(&res->ln);
 }
 
diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index aa1878e208b8..95bc1bab28f4 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/sched_trace.h>
 #include <litmus/debug_trace.h>
 #include <litmus/reservations/gedf_reservation.h>
 
@@ -94,14 +95,10 @@ static int edf_preemption_needed(rt_domain_t* rt, struct reservation* res)
 }
 
 /* ******************************************************************************** */
+//TODO: add support for checking non-preemptivity
 static void preempt(struct cpu_entry* entry)
 {
-        if (entry->scheduled) {
-                if (smp_processor_id() == entry->id)
-                        litmus_reschedule_local();
-                else
-                        litmus_reschedule(entry->id);
-        }
+        litmus_reschedule(entry->id);
 }
 
 static enum hrtimer_restart timer_callback(struct hrtimer* timer)
@@ -114,7 +111,7 @@ static void requeue(rt_domain_t* domain, struct reservation* res) {
         BUG_ON(!res);
         BUG_ON(is_queued_res(res));
 
-        if (lt_before_eq(res->next_replenishment, litmus_clock()))
+        if (lt_before_eq(res->replenishment_time, litmus_clock()))
                 __add_ready_res(domain, res);
         else
                 __add_release_res(domain, res);
@@ -123,42 +120,29 @@ static void requeue(rt_domain_t* domain, struct reservation* res) {
 
 static void link_task_to_cpu(
         struct gedf_reservation* linked,
-        struct cpu_entry* entry)
+        struct cpu_entry* entry,
+        struct gedf_reservation_environment* gedf_env)
 {
         struct cpu_entry* sched = NULL;
         struct reservation* tmp;
-        struct bheap* cpu_heap =
-                &((struct gedf_reservation_environment*)linked->res.par_env)->cpu_heap;
 
         if (entry->linked)
                 ((struct gedf_reservation*)entry->linked)->linked_on = NULL;
 
-        if (linked) {
-                sched = linked->scheduled_on;
-                if (sched) {
-                        BUG_ON(sched->linked == linked);
-                        if (entry != sched) {
-                                tmp = sched->linked;
-                                linked->linked_on = sched;
-                                sched->linked = &linked->res;
-                                update_cpu_position(sched, cpu_heap);
-                                linked = (struct gedf_reservation*)tmp;
-                        }
-                }
-                if (linked)
-                        linked->linked_on = entry;
-        }
+        if (linked)
+                linked->linked_on = entry;
+
         entry->linked = &linked->res;
-        update_cpu_position(entry, cpu_heap);
+        update_cpu_position(entry, &gedf_env->cpu_heap);
 }
 
-static void unlink(struct gedf_reservation* res)
+static void unlink(
+        struct gedf_reservation* res,
+        struct gedf_reservation_environment* gedf_env)
 {
-        struct gedf_reservation_environment* gedf_env;
         BUG_ON(!res->linked_on);
-        gedf_env = container_of(res->res.par_env, struct gedf_reservation_environment, env);
         if (res->linked_on) {
-                link_task_to_cpu(NULL, 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);
@@ -174,9 +158,9 @@ static void check_for_preemptions(struct gedf_reservation_environment* env)
                         edf_preemption_needed(&env->domain, last->linked);
                         last = lowest_prio_cpu(&env->cpu_heap)) {
                 res = (struct gedf_reservation*)__take_ready_res(&env->domain);
-                if (last->linked->cur_budget)
+                if (last->linked && last->linked->cur_budget)
                         requeue(&env->domain, last->linked);
-                link_task_to_cpu(res, last);
+                link_task_to_cpu(res, last, env);
                 preempt(last);
         }
 }
@@ -190,6 +174,13 @@ static void gedf_shutdown(
         kfree(res);
 }
 
+static void gedf_task_shutdown(
+        struct reservation *res)
+{
+        clean_up_ext_reservation(res);
+        kfree(res);
+}
+
 static void gedf_on_preempt(
         struct reservation *res,
         int cpu)
@@ -205,16 +196,48 @@ static void gedf_on_schedule(
         res->env->ops->resume(res->env, now, 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);
+}
+
+static struct task_struct* gedf_task_dispatch_client(
+        struct reservation* res,
+        lt_t now,
+        int cpu)
+{
+        return ((struct gedf_task_reservation*)res)->task;
+}
+
 static void gedf_replenish_budget(
         struct reservation* res,
         int cpu)
 {
-        struct gedf_reservation* gedf_res =
-                container_of(res, struct gedf_reservation, res);
+        struct gedf_container_reservation* gedf_cont_res =
+                (struct gedf_container_reservation*)res;
         res->budget_consumed = 0;
-        res->cur_budget = gedf_res->exec_cost;
-        res->priority = res->next_replenishment + gedf_res->relative_deadline;
-        res->next_replenishment += gedf_res->period;
+        res->cur_budget = gedf_cont_res->max_budget;
+        res->priority = res->replenishment_time + gedf_cont_res->relative_deadline;
+        res->replenishment_time += gedf_cont_res->period;
+}
+
+static void gedf_task_replenish_budget(
+        struct reservation* res,
+        int cpu)
+{
+        struct task_struct* t = ((struct gedf_task_reservation*)res)->task;
+        sched_trace_task_completion(t, !is_completed(t));
+        BUG_ON(get_exec_time(t) > 110000000);
+        tsk_rt(t)->completed = 0;
+        prepare_for_next_period(t);
+        sched_trace_task_release(t);
+        res->budget_consumed = 0;
+        res->cur_budget = get_exec_cost(t);
+        res->priority = get_deadline(t);
+        res->replenishment_time = get_release(t);
 }
 
 static void gedf_drain_budget(
@@ -232,40 +255,93 @@ static void gedf_drain_budget(
         res->env->ops->update_time(res->env, how_much, cpu);
 }
 
-static struct reservation_ops gedf_ops =
+static void gedf_task_drain_budget(
+        struct reservation* res,
+        lt_t how_much,
+        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;
+        else
+                res->cur_budget -= how_much;
+        res->budget_consumed += how_much;
+        res->budget_consumed_total += how_much;
+}
+
+static struct reservation_ops gedf_cont_ops =
 {
         .drain_budget = gedf_drain_budget,
         .replenish_budget = gedf_replenish_budget,
+        .dispatch_client = gedf_dispatch_client,
         .on_schedule = gedf_on_schedule,
         .on_preempt = gedf_on_preempt,
         .shutdown = gedf_shutdown
 };
 
-long alloc_gedf_reservation(
-        struct gedf_reservation** _res,
+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,
+        .shutdown = gedf_task_shutdown
+};
+
+long alloc_gedf_task_reservation(
+        struct gedf_task_reservation** _res,
+        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;
+
+        gedf_task_res->task = task;
+        tsk_rt(task)->plugin_state = gedf_task_res;
+
+        *_res = gedf_task_res;
+        return 0;
+}
+
+long alloc_gedf_container_reservation(
+        struct gedf_container_reservation** _res,
         int id,
-        lt_t exec_cost,
+        lt_t max_budget,
         lt_t period,
         lt_t relative_deadline)
 {
+        struct gedf_container_reservation* gedf_cont_res;
         struct gedf_reservation* gedf_res;
-        gedf_res = kzalloc(sizeof(*gedf_res), GFP_KERNEL);
-        if (!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_ops;
-        *_res = gedf_res;
+        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;
-        gedf_res->exec_cost = exec_cost;
-        gedf_res->period = period;
-        gedf_res->relative_deadline = relative_deadline;
 
+        gedf_cont_res->max_budget = max_budget;
+        gedf_cont_res->period = period;
+        gedf_cont_res->relative_deadline = relative_deadline;
+
+        *_res = gedf_cont_res;
         return 0;
 }
 
@@ -294,8 +370,7 @@ static void gedf_env_shutdown(
         kfree(env);
 }
 
-/* can only be called when res is scheduled.
- * this only marks for removal, actual removal is done in the subsequent schedule()
+/* This assumes that is is only called from res itself requesting to be removed
  */
 static void gedf_env_remove_res(
         struct reservation_environment* env,
@@ -312,8 +387,9 @@ static void gedf_env_remove_res(
         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);
-        preempt(gedf_res->scheduled_on);
+        unlink(gedf_res, gedf_env);
+        if (gedf_res->scheduled_on)
+                preempt(gedf_res->scheduled_on);
         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)
@@ -365,7 +441,7 @@ static void gedf_env_suspend(
         /*
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
         if (entry->linked) {
-                unlink(entry->linked);
+                unlink(entry->linked, gedf_env);
                 requeue(entry->linked);
         }
         bheap_delete(cpu_lower_prio, &gedf_env->cpu_heap, entry->hn);
@@ -402,7 +478,7 @@ static void gedf_env_resume(
         if (entry->scheduled)
                 hrtimer_start(
                         &entry->timer,
-                        ns_to_ktime(now + entry->scheduled->cur_budget),
+                        ns_to_ktime(litmus_clock() + entry->scheduled->cur_budget),
                         HRTIMER_MODE_ABS_PINNED);
 }
 
@@ -425,9 +501,9 @@ static struct task_struct* gedf_env_dispatch(
 
         check_for_preemptions(gedf_env);
         if (entry->scheduled != entry->linked) {
-                if (entry->scheduled)
+                if (entry->scheduled && entry->scheduled->ops->on_preempt)
                         entry->scheduled->ops->on_preempt(entry->scheduled, cpu);
-                if (entry->linked)
+                if (entry->linked && entry->linked->ops->on_schedule)
                         entry->linked->ops->on_schedule(entry->linked, now, cpu);
                 entry->scheduled = entry->linked;
         }
@@ -435,12 +511,13 @@ static struct task_struct* gedf_env_dispatch(
 
         //TODO: Think about possible problems with entry->scheduled being changed
         if (entry->scheduled) {
-                next = entry->scheduled->env->ops->dispatch(entry->scheduled->env, now, cpu);
-
+                next = entry->scheduled->ops->dispatch_client(entry->scheduled, now, cpu);
                 hrtimer_start(&entry->timer,
-                        ns_to_ktime(now + entry->scheduled->cur_budget),
+                        ns_to_ktime(litmus_clock() + entry->scheduled->cur_budget),
                         HRTIMER_MODE_ABS_PINNED);
         }
+        else
+                hrtimer_try_to_cancel(&entry->timer);
 
         return next;
 }
@@ -475,7 +552,7 @@ static void gedf_env_update_time(
                 /* unlink and requeue if not blocked */
                 if (!gedf_res->blocked) {
                         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
-                        unlink((struct gedf_reservation*)entry->scheduled);
+                        unlink((struct gedf_reservation*)entry->scheduled, gedf_env);
                         requeue(&gedf_env->domain, entry->scheduled);
                         check_for_preemptions(gedf_env);
                         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
diff --git a/litmus/reservations/task_reservation.c b/litmus/reservations/task_reservation.c
deleted file mode 100644
index ee4bbbc5ed07..000000000000
--- a/litmus/reservations/task_reservation.c
+++ /dev/null
@@ -1,89 +0,0 @@
-#include <linux/slab.h>
-
-#include <litmus/litmus.h>
-#include <litmus/reservations/ext_reservation.h>
-#include <litmus/reservations/task_reservation.h>
-
-static void task_env_shutdown(
-        struct reservation_environment* env)
-{
-        struct task_reservation_environment* task_env =
-                container_of(env, struct task_reservation_environment, env);
-        tsk_rt(task_env->task)->plugin_state = NULL;
-        kfree(env);
-        return;
-}
-
-static void task_env_remove_res(
-        struct reservation_environment* env,
-        struct reservation* res,
-        int complete)
-{
-        return;
-}
-
-static void task_env_add_res(
-        struct reservation_environment* env,
-        struct reservation* res)
-{
-        return;
-}
-
-static void task_env_suspend(
-        struct reservation_environment* env,
-        int cpu)
-{
-        return;
-}
-
-static void task_env_resume(
-        struct reservation_environment* env,
-        lt_t now, int cpu)
-{
-        return;
-}
-
-static struct task_struct* task_env_dispatch(
-        struct reservation_environment* env,
-        lt_t now,
-        int cpu)
-{
-        struct task_reservation_environment* task_env =
-                container_of(env, struct task_reservation_environment, env);
-        return task_env->task;
-}
-
-static void task_env_update_time(
-        struct reservation_environment* env,
-        lt_t how_much,
-        int cpu)
-{
-        return;
-}
-
-static struct reservation_environment_ops task_env_ops = {
-        .update_time = task_env_update_time,
-        .dispatch = task_env_dispatch,
-        .resume = task_env_resume,
-        .suspend = task_env_suspend,
-        .add_res = task_env_add_res,
-        .remove_res = task_env_remove_res,
-        .shutdown = task_env_shutdown
-};
-
-long alloc_task_reservation_environment(
-        struct task_reservation_environment** _env,
-        struct task_struct* task)
-{
-        struct task_reservation_environment* task_env;
-        task_env = kzalloc(sizeof(struct task_reservation_environment), GFP_KERNEL);
-        if (!task_env)
-                return -ENOMEM;
-
-        task_env->task = task;
-        task_env->env.ops = &task_env_ops;
-        tsk_rt(task)->plugin_state = task_env;
-
-        *_env = task_env;
-        return 0;
-}
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 62fac871a349..4c37341065f0 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -71,7 +71,7 @@ static void release_jobs_before_now(rt_domain_t* rt)
          * from the release queue and call release callback
          */
         while(!binheap_empty(&rt->release_queue.queue) &&
-                        lt_before_eq(litmus_clock(), rt->release_queue.earliest_release)) {
+                        lt_before_eq(rt->release_queue.earliest_release, litmus_clock())) {
                 raw_spin_lock_irqsave(&rt->release_lock, flags);
                 VTRACE("CB has the release_lock 0x%p\n", &rt->release_lock);
 
@@ -206,7 +206,7 @@ static struct release_heap* get_release_heap_res(rt_domain_t *rt,
                                                  struct reservation* res,
                                                  int use_task_heap)
 {
-        return __get_release_heap(rt, res->next_replenishment, res->rel_heap, use_task_heap);
+        return __get_release_heap(rt, res->replenishment_time, res->rel_heap, use_task_heap);
 }
 
 static struct release_heap* get_release_heap(rt_domain_t *rt,
diff --git a/litmus/sched_ext_res.c b/litmus/sched_ext_res.c
index 3c34985bba85..e79986a12b2c 100644
--- a/litmus/sched_ext_res.c
+++ b/litmus/sched_ext_res.c
@@ -14,7 +14,6 @@
 #include <litmus/sched_trace.h>
 
 #include <litmus/reservations/ext_reservation.h>
-#include <litmus/reservations/task_reservation.h>
 #include <litmus/reservations/gedf_reservation.h>
 
 struct gedf_reservation_environment* gedf_env;
@@ -69,11 +68,14 @@ static struct task_struct* ext_res_schedule(struct task_struct * prev)
 
         now = litmus_clock();
         delta = now - *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);
 
+        *this_cpu_ptr(&last_update_time) = litmus_clock();
+
         sched_state_task_picked();
 
         return next;
@@ -83,13 +85,11 @@ static struct task_struct* ext_res_schedule(struct task_struct * prev)
  */
 static void ext_res_task_block(struct task_struct *tsk)
 {
-        struct task_reservation_environment* task_env;
         struct reservation* res;
 
         TRACE_TASK(tsk, "thread suspends at %llu \n", litmus_clock());
 
-        task_env = (struct task_reservation_environment*) tsk_rt(tsk)->plugin_state;
-        res = task_env->env.res;
+        res = (struct reservation*) tsk_rt(tsk)->plugin_state;
         res->par_env->ops->remove_res(res->par_env, res, 0);
 }
 
@@ -99,38 +99,25 @@ static void ext_res_task_block(struct task_struct *tsk)
  */
 static void ext_res_task_resume(struct task_struct  *tsk)
 {
-        struct task_reservation_environment* task_env;
         struct reservation* res;
 
         TRACE_TASK(tsk, "thread wakes up at %llu\n", litmus_clock());
 
-        task_env = (struct task_reservation_environment*) tsk_rt(tsk)->plugin_state;
-        res = task_env->env.res;
+        res = (struct reservation*) tsk_rt(tsk)->plugin_state;
         res->par_env->ops->add_res(res->par_env, res);
 }
 
 static long ext_res_admit_task(struct task_struct *tsk)
 {
-        long err;
-
-        struct gedf_reservation* gedf_res;
-        struct task_reservation_environment* task_env;
+        long err = 0;
 
-        err = alloc_gedf_reservation(
-                &gedf_res,
-                tsk->pid,
-                get_exec_cost(tsk),
-                get_rt_period(tsk),
-                get_rt_relative_deadline(tsk)
-        );
-        if (err)
-                return err;
+        struct gedf_task_reservation* gedf_task_res;
 
-        err = alloc_task_reservation_environment(&task_env, tsk);
+        err = alloc_gedf_task_reservation(&gedf_task_res, tsk);
         if (err)
                 return err;
 
-        env_to_res_couple(&task_env->env, &gedf_res->res);
+        gedf_task_res->gedf_res.res.par_env = &gedf_env->env;
 
         //TODO: for checkpoint 2, need to find component and insert into it
 
@@ -140,16 +127,16 @@ static long ext_res_admit_task(struct task_struct *tsk)
 static void ext_res_task_new(struct task_struct *tsk, int on_runqueue,
                           int is_running)
 {
-        struct task_reservation_environment* task_env;
         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);
 
-        task_env = (struct task_reservation_environment*)tsk_rt(tsk)->plugin_state;
-        res = task_env->env.res;
-        res->next_replenishment = now;
+        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);
 
@@ -177,12 +164,10 @@ static bool pres_fork_task(struct task_struct *tsk)
 
 static void ext_res_task_exit(struct task_struct *tsk)
 {
-        struct task_reservation_environment* task_env;
         struct reservation* res;
         struct reservation_environment* par_env;
 
-        task_env = (struct task_reservation_environment*)tsk_rt(tsk)->plugin_state;
-        res = task_env->env.res;
+        res = (struct reservation*)tsk_rt(tsk)->plugin_state;
         par_env = res->par_env;
 
         par_env->ops->remove_res(par_env, res, 1);
@@ -326,11 +311,13 @@ static long ext_res_activate_plugin(void)
 {
         int cpu;
         int num_cpus = num_online_cpus();
+        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;
                 gedf_env->cpu_mapping[cpu] = cpu;
                 gedf_env->cpu_entries[cpu].id = cpu;
         }