Changed the way slack timers are armed.

A different hrtimer_start_on_info struct must be used for each timer.
This is used to migrate the slack timers to the proper cpus when the plugin
is activated. Repeatedly using this struct to arm the slack timer wasn't
working, so now the slack timer arm method arms on the local CPU.

1 files changed, 22 insertions, 18 deletions

diff --git a/litmus/sched_edf_hsb.c b/litmus/sched_edf_hsb.c
index 751f276da595..73d7c6b2fc31 100755
--- a/litmus/sched_edf_hsb.c
+++ b/litmus/sched_edf_hsb.c
@@ -54,7 +54,11 @@ struct cpu_entry {
         int                             cpu;
         struct task_struct*             scheduled;
         struct task_struct*             linked;
-        struct hrtimer_start_on_info    hrtimer_info;
+
+        /* Used to execute timers on remote CPUs */
+        struct hrtimer_start_on_info    budget_timer_info;
+        struct hrtimer_start_on_info    slack_timer_info;
+
         struct hrt_server               hrt_server;
 };
 
@@ -260,7 +264,8 @@ void initialize_cpu_variables(void)
 
                 /* CPU entries */
                 cpu_entry->cpu = cpu;
-                hrtimer_start_on_info_init(&cpu_entry->hrtimer_info);
+                hrtimer_start_on_info_init(&cpu_entry->budget_timer_info);
+                hrtimer_start_on_info_init(&cpu_entry->slack_timer_info);
 
                 /* HRT servers */
                 rwlock_init(&hrt_server->param_lock);
@@ -549,31 +554,26 @@ static enum hrtimer_restart refill_timer_fire(struct hrtimer *timer)
 static void slack_timer_arm(struct hrt_server *server)
 {
         struct hrtimer *timer = &server->slack_timer;
-        struct cpu_entry *entry = container_of(server,
-                                               struct cpu_entry,
-                                               hrt_server);
         lt_t when_to_fire = server->deadline - server->budget;
 
         if (server->no_slack || server->budget <= 0) {
-                TRACE("cancel slack timer arm");
+                TRACE("not arming slack timer");
                 return;
         }
 
-
         BUG_ON(hrtimer_active(timer));
         BUG_ON(hrtimer_active(&server->budget_timer));
 
-        /* kind of ridiculous to check this, but whatever... */
         BUG_ON(server->budget >= server->deadline);
-        /* Can this happen? */
         BUG_ON(lt_after_eq(litmus_clock(), when_to_fire));
 
         TRACE("slack armed to fire at %llu", when_to_fire);
 
-        hrtimer_start_on(entry->cpu, &entry->hrtimer_info,
-                         timer,
-                         ns_to_ktime(when_to_fire),
-                         HRTIMER_MODE_ABS_PINNED);
+        __hrtimer_start_range_ns(timer,
+                                 ns_to_ktime(when_to_fire),
+                                 0 /* delta */,
+                                  HRTIMER_MODE_ABS_PINNED,
+                                 0 /* no wakeup */);
 }
 
 static enum hrtimer_restart slack_timer_fire(struct hrtimer *timer)
@@ -585,8 +585,7 @@ static enum hrtimer_restart slack_timer_fire(struct hrtimer *timer)
         local_irq_save(flags);
         server->no_slack = 1;
 
-        TRACE("slack timer fired on cpu %d at litmus time: %llu\n",
-                        entry->cpu, litmus_clock());
+        TRACE("slack timer fired at litmus time: %llu\n", litmus_clock());
 
         /* activate scheduler */
         litmus_reschedule_local();
@@ -607,7 +606,7 @@ static enum hrtimer_restart slack_timer_fire(struct hrtimer *timer)
  */
 static long edf_hsb_activate_plugin(void)
 {
-        lt_t common_server_start = litmus_clock();
+        lt_t slack_fire, common_server_start = litmus_clock();
         struct cpu_entry *cpu_entry;
         struct hrt_server* server;
         long rv = 0;
@@ -628,15 +627,20 @@ static long edf_hsb_activate_plugin(void)
                 server->deadline = common_server_start + server->period;
                 server->budget = server->wcet;
                 server->start_exec_time = 0;
+                slack_fire = server->deadline - server->budget;
 
                 TRACE("setting up cpu %d to have timer deadline %llu\n",
                                 cpu, server->deadline);
-                hrtimer_start_on(cpu, &cpu_entry->hrtimer_info,
+                hrtimer_start_on(cpu, &cpu_entry->budget_timer_info,
                                 &server->refill_timer,
                                 ns_to_ktime(server->deadline),
                                 HRTIMER_MODE_ABS_PINNED);
 
-                slack_timer_arm(server);
+                hrtimer_start_on(cpu, &cpu_entry->slack_timer_info,
+                                 &server->slack_timer,
+                                 ns_to_ktime(slack_fire),
+                                HRTIMER_MODE_ABS_PINNED);
+
         }
 out:
         return rv;