Use watchdog timers (compiles, but not tested yet.)

1 files changed, 91 insertions, 6 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 0f5da078c597..63dd157925ab 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -13,6 +13,7 @@
 #include <linux/spinlock.h>
 #include <linux/percpu.h>
 #include <linux/sched.h>
+#include <linux/hrtimer.h>
 
 #include <litmus/litmus.h>
 #include <litmus/jobs.h>
@@ -99,6 +100,16 @@ typedef struct  {
         struct task_struct*     ghost_tasks[CRIT_LEVEL_D+1];
 } cpu_entry_t;
 
+/*This code is heavily based on Bjoern's budget enforcement code. */
+struct watchdog_timer {
+        /* The watchdog timers determine when ghost jobs finish. */
+        struct hrtimer          timer;
+        struct task_struct*     task;
+};
+
+DEFINE_PER_CPU(struct watchdog_timer[CRIT_LEVEL_D+1], ghost_timers);
+#define ghost_timer(cpu, crit) (&(per_cpu(ghost_timers, cpu)[crit]))
+
 DEFINE_PER_CPU(cpu_entry_t, mc_cpu_entries);
 
 cpu_entry_t* mc_cpus[NR_CPUS];
@@ -328,7 +339,7 @@ static void update_ghost_time(struct task_struct *p)
         u64 clock;
         
         BUG_ON(!is_ghost(p));
-        clock = cpu_clock(p->rt_param.linked_on);
+        clock = litmus_clock();
         delta = clock - p->se.exec_start;
         if (unlikely ((s64)delta < 0)) {
                 delta = 0;
@@ -344,6 +355,25 @@ static void update_ghost_time(struct task_struct *p)
 }
 
 
+/* 
+ * 
+ */
+static void cancel_watchdog_timer(struct watchdog_timer* wt)
+{
+        int ret;
+
+        if (wt->task) {
+                TRACE_TASK(wt->task, "Cancelling watchdog timer.\n");
+                ret = hrtimer_try_to_cancel(&wt->timer);
+                /*Should never be inactive.*/
+                BUG_ON(ret == 0);
+                /*Should never be running concurrently. */
+                BUG_ON(ret == -1);
+
+                wt->task = NULL;
+        }
+}
+
 /* link_task_to_cpu - Update the link of a CPU.
  *                    Handles the case where the to-be-linked task is already
  *                    scheduled on a different CPU.
@@ -358,6 +388,8 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
         struct task_struct* tmp;
         int on_cpu;
         int i;
+        struct watchdog_timer* timer;
+        lt_t when_to_fire;
 
         BUG_ON(linked && !is_realtime(linked));
         BUG_ON(linked && is_realtime(linked) &&
@@ -378,8 +410,22 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                  */
                 BUG_ON(linked->rt_param.linked_on != NO_CPU);
                 linked->rt_param.linked_on = entry->cpu;
-                linked->se.exec_start = cpu_clock(entry->cpu);
+                linked->se.exec_start = litmus_clock();
                 entry->ghost_tasks[linked->rt_param.task_params.crit] = linked;
+                /* Set up the watchdog timer. */
+                timer = ghost_timer(entry->cpu,
+                                linked->rt_param.task_params.crit);
+                if (timer->task){
+                        cancel_watchdog_timer(timer);
+                }
+                when_to_fire = litmus_clock() +
+                                linked->rt_param.job_params.ghost_budget;
+                timer->task = linked;
+                __hrtimer_start_range_ns(&timer->timer,
+                        ns_to_ktime(when_to_fire),
+                        0 /* delta */,
+                        HRTIMER_MODE_ABS_PINNED,
+                        0 /* no wakeup */);
         }
         else{
                 /* Currently linked task is set to be unlinked. */
@@ -465,6 +511,7 @@ static noinline void unlink(struct task_struct* t)
 {
         int cpu;
         cpu_entry_t *entry;
+        struct watchdog_timer *timer;
 
         if (unlikely(!t)) {
                 TRACE_BUG_ON(!t);
@@ -477,6 +524,12 @@ static noinline void unlink(struct task_struct* t)
                 entry = remote_cpu_entry(cpu);
                 t->rt_param.linked_on = NO_CPU;
                 if (is_ghost(t)) {
+                        /* Clear the timer.*/
+                        timer = ghost_timer(cpu,
+                                        t->rt_param.task_params.crit);
+                        /* Should already be watching task.*/
+                        BUG_ON(timer->task != t);
+                        cancel_watchdog_timer(timer);
                         if (t->rt_param.job_params.ghost_budget > 0){
                                 /* Job isn't finished, so do accounting. */
                                 update_ghost_time(t);
@@ -686,7 +739,9 @@ static noinline void job_completion(struct task_struct *t, int forced)
 
         /* set flags */
         set_rt_flags(t, RT_F_SLEEP);
-        /*If it's not a ghost job, do ghost job conversion and return.*/
+        /* If it's not a ghost job, do ghost job conversion and return if
+         * needed.
+         */
         if (!is_ghost(t)) {
                 cpu = remote_cpu_entry(t->rt_param.scheduled_on);
                 /*Unlink first while it's not a ghost job.*/
@@ -697,6 +752,12 @@ static noinline void job_completion(struct task_struct *t, int forced)
                 /* If we did just convert the job to ghost, we can safely
                  * reschedule it and then let schedule() determine a new
                  * job to run in the slack.
+                 *
+                 * If it actually needs to run as a ghost job, we'll do so
+                 * here.
+                 *
+                 * If it doesn't need to, it will fall through and be handled
+                 * properly as well.
                  */
                 if (t->rt_param.job_params.ghost_budget > 0){
                         link_task_to_cpu(t, cpu);
@@ -705,9 +766,6 @@ static noinline void job_completion(struct task_struct *t, int forced)
                 }
         }
         /* prepare for next period */
-        /* TODO: check what happens if we actually finish with exactly our
-         * budget and never convert to ghost
-         */
         if (is_ghost(t)) {
                 t->rt_param.job_params.ghost_budget = 0;
                 prepare_for_next_period(t);
@@ -726,6 +784,26 @@ static noinline void job_completion(struct task_struct *t, int forced)
                 mc_job_arrival(t);
 }
 
+/* watchdog_timeout - this function is called when a watchdog timer expires.
+ * 
+ * Acquires global lock
+ */
+
+static enum hrtimer_restart watchdog_timeout(struct hrtimer *timer)
+{
+        struct watchdog_timer* wt = container_of(timer,
+                                                 struct watchdog_timer,
+                                                 timer);
+        unsigned long flags;
+        raw_spin_lock_irqsave(&global_lock, flags);
+        /*If we have triggered, we know the budget must have expired.*/
+        wt->task->rt_param.job_params.ghost_budget = 0;
+        job_completion(wt->task, 0);
+        raw_spin_unlock_irqrestore(&global_lock, flags);
+        return HRTIMER_NORESTART;
+}
+
+
 /* mc_tick - this function is called for every local timer
  *                         interrupt.
  *
@@ -1144,6 +1222,7 @@ static int __init init_mc(void)
         int cpu;
         int i;
         cpu_entry_t *entry;
+        struct watchdog_timer *timer;
 
         bheap_init(&mc_cpu_heap_c);
         bheap_init(&mc_cpu_heap_d);
@@ -1157,6 +1236,12 @@ static int __init init_mc(void)
                 entry->hn_d      = &mc_heap_node_d[cpu];
                 bheap_node_init(&entry->hn_c, entry);
                 bheap_node_init(&entry->hn_d, entry);
+                for (i = CRIT_LEVEL_A; i <= CRIT_LEVEL_D; i++){
+                        timer = ghost_timer(cpu, i);
+                        hrtimer_init(&timer->timer, CLOCK_MONOTONIC,
+                                HRTIMER_MODE_ABS);
+                        timer->timer.function = watchdog_timeout;
+                }
         }
         mc_edf_domain_init(&crit_c, NULL, mc_release_jobs);
         mc_edf_domain_init(&crit_d, NULL, mc_release_jobs);