HRT and SRT both working together.

1 files changed, 80 insertions, 70 deletions

diff --git a/litmus/sched_edf_hsb.c b/litmus/sched_edf_hsb.c
index 9aeed5d413a8..ac8994e87cca 100644
--- a/litmus/sched_edf_hsb.c
+++ b/litmus/sched_edf_hsb.c
@@ -238,6 +238,8 @@ static inline void update_cpu_position(cpu_entry_t *entry)
 }
 
 /*
+
+
  * Caller must hold global lock.
  */
 static inline cpu_entry_t* lowest_prio_cpu(void)
@@ -255,6 +257,7 @@ static inline cpu_entry_t* lowest_prio_cpu(void)
  */
 static void slack_timer_arm(hrt_server_t *server)
 {
+        cpu_entry_t *entry = container_of(server, cpu_entry_t, hrt_server);
         struct hrtimer *timer = &server->slack_timer;
         lt_t when_to_fire = get_server_deadline(server) -
                 get_server_budget(server);
@@ -273,15 +276,16 @@ static void slack_timer_arm(hrt_server_t *server)
         }
 
         BUG_ON(when_to_fire >= get_server_deadline(server));
+        BUG_ON(entry->cpu != smp_processor_id());
 
         if (lt_after_eq(litmus_clock(), when_to_fire)) {
                 TRACE_SUB("slack timer fired immediately, time was %llu,",
                           TIME(when_to_fire));
                 server->no_slack = 1;
         } else {
-                TRACE_SUB("slack timer armed to fire at %llu,", TIME(when_to_fire));
-                __hrtimer_start_range_ns(timer,
-                                         ns_to_ktime(when_to_fire),
+                TRACE_SUB("slack timer armed to fire at %llu on %d",
+                          TIME(when_to_fire), entry->cpu);
+                __hrtimer_start_range_ns(timer, ns_to_ktime(when_to_fire),
                                          0 /* delta */,
                                          HRTIMER_MODE_ABS_PINNED,
                                          0 /* no wakeup */);
@@ -293,6 +297,8 @@ static void slack_timer_arm(hrt_server_t *server)
  */
 static inline void slack_timer_cancel(hrt_server_t *server)
 {
+        cpu_entry_t *entry = container_of(server, cpu_entry_t, hrt_server);
+        TRACE_SUB("cancelling slack timer on P%d", entry->cpu);
         if (hrtimer_active(&server->slack_timer))
                 hrtimer_try_to_cancel(&server->slack_timer);
 }
@@ -329,8 +335,6 @@ static noinline void link_server(cpu_entry_t *entry,
 {
         srt_state_t *server_state;
 
-        slack_timer_cancel(&entry->hrt_server);
-
         if (is_srt(entry->linked)) {
                 server_state = tsk_rt(entry->linked)->plugin_data;
 
@@ -361,6 +365,9 @@ static noinline void link_server(cpu_entry_t *entry,
 
                 entry->linked_server = (server_t*)&entry->srt_server;
         } else if (is_hrt(entry->linked)) {
+                /* HRT servers should never, ever migrate */
+                BUG_ON(entry->cpu != task_cpu(entry->linked));
+
                 entry->linked_server = (server_t*)&entry->hrt_server;
         } else { /* BE */
                 BUG_ON(!be_server);
@@ -368,9 +375,6 @@ static noinline void link_server(cpu_entry_t *entry,
         }
 
         server_run(entry->linked_server, entry->linked);
-
-        if (!is_hrt(entry->linked))
-                slack_timer_arm(&entry->hrt_server);
 }
 
 /*
@@ -382,9 +386,6 @@ static noinline void unlink_server(cpu_entry_t *entry)
 {
         srt_state_t *server_state;
 
-        if (!entry->linked || !is_hrt(entry->linked))
-                slack_timer_cancel(&entry->hrt_server);
-
         if (entry->linked_server) {
                 server_stop(entry->linked_server);
 
@@ -422,8 +423,6 @@ static noinline void unlink_server(cpu_entry_t *entry)
 
                 entry->linked_server = NULL;
         }
-
-        slack_timer_arm(&entry->hrt_server);
 }
 
 /* Update the link of a CPU.
@@ -441,6 +440,7 @@ static noinline void link_task_to_cpu(cpu_entry_t *entry,
         int on_cpu;
 
         BUG_ON(linked && !is_realtime(linked));
+        BUG_ON(linked && is_hrt(linked) && entry->cpu != task_cpu(linked));
 
         /* Currently linked task is set to be unlinked. */
         if (entry->linked) {
@@ -458,18 +458,21 @@ static noinline void link_task_to_cpu(cpu_entry_t *entry,
                         /* this should only happen if not linked already */
                         BUG_ON(sched->linked == linked);
 
-                        /* If we are already scheduled on the CPU to which we
-                         * wanted to link, we don't need to do the swap --
-                         * we just link ourselves to the CPU and depend on
-                         * the caller to get things right.
+                        /* If we are already scheduled on a CPU to which
+                         * we are not linked, then a task is linked but not
+                         * scheduled on another CPU. We can link that task here
+                         * and just re-link ourselves to the other CPU for the
+                         * same effect. Note that since HRT tasks cannot migrate,
+                         * they can never participate in this swap.
                          */
-                        if (entry != sched) {
+                        if (entry != sched && !is_hrt(linked) &&
+                            (!sched->linked || !is_hrt(sched->linked))) {
                                 TRACE_TASK_SUB(linked,
                                            "already scheduled on %d, updating link.",
                                            sched->cpu);
+
                                 tmp_task = sched->linked;
                                 tmp_server = sched->linked_server;
-
                                 unlink_server(sched);
 
                                 linked->rt_param.linked_on = sched->cpu;
@@ -489,6 +492,7 @@ static noinline void link_task_to_cpu(cpu_entry_t *entry,
         if (linked)
                 link_server(entry, be_server);
 
+
         if (linked)
                 TRACE_TASK_SUB(linked, "linked to %d.", entry->cpu);
         else
@@ -542,6 +546,8 @@ static noinline void unlink(struct task_struct* t)
  */
 static inline int is_eligible(struct task_struct *task, hrt_server_t *server)
 {
+        TRACE_SUB("slack: %d, svd: %llu, tdu: %llu", server->no_slack,
+                  get_server_deadline(server), get_deadline(task));
         return server->no_slack ||
                 lt_after_eq(get_server_deadline(server), get_deadline(task));
 }
@@ -618,30 +624,6 @@ static void preempt(cpu_entry_t *entry, struct task_struct *next,
         preempt_if_preemptable(entry->scheduled, entry->cpu);
 }
 
-/*
- * Correct local link after a change to the local HRT domain.
- */
-static void check_for_hrt_preempt(cpu_entry_t *entry)
-{
-        hrt_server_t *server = &entry->hrt_server;
-        struct task_struct *next_hrt = next_eligible_hrt(server);
-
-        TRACE_SUB("checking for HRT preempt");
-
-        if (next_hrt &&
-            (!entry->linked || !is_hrt(entry->linked) ||
-             edf_preemption_needed(&server->hrt_domain, entry->linked))) {
-
-                TRACE_TASK_SUB(next_hrt, "preempting on CPU %d", entry->cpu);
-                remove(&server->hrt_domain, next_hrt);
-                preempt(entry, next_hrt, NULL);
-        } else {
-                TRACE_SUB("not preempting, Next: %d, Scheduled: %d, is_srt: %d",
-                          !!next_hrt, !!entry->linked,
-                          (entry->linked) ? is_srt(entry->linked) : 0);
-        }
-}
-
 static struct task_struct* check_for_srt_preempt(cpu_entry_t *entry)
 {
         be_server_t *linked_server;
@@ -765,13 +747,44 @@ static void check_for_global_preempt(void)
 }
 
 /*
+ * Correct local link after a change to the local HRT domain.
+ */
+static void check_for_hrt_preempt(cpu_entry_t *entry)
+{
+        hrt_server_t *server = &entry->hrt_server;
+        struct task_struct *next_hrt = next_eligible_hrt(server);
+        struct task_struct *curr = entry->linked;
+
+        TRACE_SUB("checking for HRT preempt on P%d", entry->cpu);
+
+        if (next_hrt &&
+            (!entry->linked || !is_hrt(entry->linked) ||
+             edf_preemption_needed(&server->hrt_domain, entry->linked))) {
+
+                TRACE_TASK_SUB(next_hrt, "preempting on CPU %d", entry->cpu);
+                remove(&server->hrt_domain, next_hrt);
+                preempt(entry, next_hrt, NULL);
+
+                /* We might have just kicked off an SRT. Check to see if it
+                 * preempts anything.
+                 */
+                if (curr && !is_hrt(curr))
+                        check_for_global_preempt();
+        } else {
+                TRACE_SUB("not preempting, Next: %d, Scheduled: %d, is_srt: %d",
+                          !!next_hrt, !!entry->linked,
+                          (entry->linked) ? is_srt(entry->linked) : 0);
+        }
+}
+
+/*
  * Assumes called with local irqs disabled.
  */
 static void job_arrival(struct task_struct *task, cpu_entry_t *entry)
 {
         int was_empty;
         BUG_ON(task_cpu(task) == NO_CPU);
-        TRACE_TASK_SUB(task, "Arriving");
+        TRACE_TASK_SUB(task, "Arriving on P%d", entry->cpu);
 
         if (is_hrt(task)) {
                 requeue(task, &entry->hrt_server.hrt_domain);
@@ -860,8 +873,6 @@ static void release_hrt_jobs(rt_domain_t *domain, struct bheap *tasks)
         first = (struct task_struct*)bheap_peek(edf_ready_order, tasks)->value;
         entry = task_sched_entry(first);
 
-        raw_spin_lock_irqsave(global_lock, flags);
-
         BUG_ON(!first || !is_hrt(first));
         TRACE_TASK(first, "HRTs released at %llu on %d\n",
                    TIME(litmus_clock()), task_cpu(first));
@@ -1002,9 +1013,7 @@ static void server_completed(server_t *server, struct task_struct *was_running)
 
                 /* Otherwise we need to pick another task to run */
                 requeue(was_running, get_rt_domain(entry, was_running));
-
                 edf_hsb_pick_next(entry);
-
                 preempt_if_preemptable(entry->scheduled, entry->cpu);
         }
 }
@@ -1023,8 +1032,7 @@ static void hrt_server_released(pserver_t *_server)
 
         server->no_slack = 0;
         check_for_hrt_preempt(entry);
-        if (!entry->linked || !is_hrt(entry->linked))
-                slack_timer_arm(server);
+        slack_timer_arm(server);
 }
 
 /*
@@ -1243,33 +1251,35 @@ static void stop_hrt_servers(void)
  */
 static void start_servers(lt_t time)
 {
-        /* int cpu; */
-        /* lt_t slack_fire; */
-        /* cpu_entry_t *entry; */
-        /* pserver_t   *server; */
+        int cpu;
+        lt_t slack_fire;
+        cpu_entry_t *entry;
+        pserver_t   *server;
         /* be_server_t *be_server; */
         /* struct list_head *pos; */
 
-        /* /\* Start HRT servers *\/ */
-        /* for_each_online_cpu(cpu) { */
-        /*      entry  = &per_cpu(cpu_entries, cpu); */
-        /*      server = &entry->hrt_server.pserver; */
+        /* Start HRT servers */
+        for_each_online_cpu(cpu) {
+                entry  = &per_cpu(cpu_entries, cpu);
+                server = &entry->hrt_server.pserver;
+
 
-        /*      TRACE("Setting up cpu %d to have timer deadline %llu\n", */
-        /*            cpu, TIME(get_server_deadline(server))); */
+                /* This should never be armed at server release */
+                slack_timer_cancel(&entry->hrt_server);
 
-        /*      /\* This should never be armed at server release *\/ */
-        /*      slack_timer_cancel(&entry->hrt_server); */
+                TRACE("Setting up cpu %d to have timer deadline %llu\n",
+                      cpu, TIME(get_server_deadline(server)));
 
-        /*      pserver_start_cpu_releasing(server, time, cpu); */
+                pserver_start_cpu_releasing(server, time, cpu);
 
-        /*      slack_fire = get_server_deadline(server) - */
-        /*              get_server_budget(server); */
-        /*      hrtimer_start_on(cpu, &per_cpu(slack_timer_infos, cpu), */
-        /*                       &entry->hrt_server.slack_timer, */
-        /*                       ns_to_ktime(slack_fire), */
-        /*                       HRTIMER_MODE_ABS_PINNED); */
-        /* } */
+                slack_fire = get_server_deadline(server) -
+                        get_server_budget(server);
+                TRACE_SUB("slack armed to fire at %llu", TIME(slack_fire));
+                hrtimer_start_on(cpu, &per_cpu(slack_timer_infos, cpu),
+                                 &entry->hrt_server.slack_timer,
+                                 ns_to_ktime(slack_fire),
+                                 HRTIMER_MODE_ABS_PINNED);
+        }
 
         /* /\* Start BE servers *\/ */
         /* list_for_each(pos, &be_servers) { */