1 files changed, 65 insertions, 35 deletions

diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index c5c4d4947c5a..073f0f4db821 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -455,45 +455,67 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         if (exists)
                 TRACE_TASK(prev,
                            "blocks:%d out_of_time:%d np:%d sleep:%d preempt:%d "
-                           "state:%d sig:%d\n",
+                           "state:%d sig:%d boosted:%d\n",
                            blocks, out_of_time, np, sleep, preempt,
-                           prev->state, signal_pending(prev));
+                           prev->state, signal_pending(prev),
+                           is_priority_boosted(entry->scheduled));
         if (entry->linked && preempt)
                 TRACE_TASK(prev, "will be preempted by %s/%d\n",
                            entry->linked->comm, entry->linked->pid);
 
 #ifdef CONFIG_SCHED_PGM
-        if (exists && is_pgm_waiting(entry->scheduled)) {
-                if (!is_priority_boosted(entry->scheduled)) {
-                        TRACE_TASK(entry->scheduled, "is waiting for PGM tokens.\n");
-                        BUG_ON(is_pgm_satisfied(entry->scheduled));
-
-                        /* Boost priority so we'll be scheduled immediately
-                           when needed tokens arrive. */
-                        tsk_rt(entry->scheduled)->priority_boosted = 1;
-                        tsk_rt(entry->scheduled)->boost_start_time = litmus_clock();
-
-                        if (unlikely(!blocks)) {
-                                /* Task has probably blocked on an inbound token socket, but
-                                   if not, re-evaluate scheduling decisions */
-                                unlink(entry->scheduled);
-                                gsnedf_job_arrival(entry->scheduled);
+        if (exists) {
+                if (is_pgm_sending(entry->scheduled)) {
+                        if (!is_pgm_satisfied(entry->scheduled)) {
+                                if (!is_priority_boosted(entry->scheduled)) {
+                                        TRACE_TASK(entry->scheduled, "is sending PGM tokens and needs boosting.\n");
+                                        BUG_ON(is_pgm_satisfied(entry->scheduled));
+
+                                        /* We are either sending tokens or waiting for tokes.
+                                           If waiting: Boost priority so we'll be scheduled
+                                                immediately when needed tokens arrive.
+                                           If sending: Boost priority so no one (specifically, our
+                                                consumers) will preempt us while signalling the token
+                                                transmission.
+                                        */
+                                        tsk_rt(entry->scheduled)->priority_boosted = 1;
+                                        tsk_rt(entry->scheduled)->boost_start_time = litmus_clock();
+
+                                        if (likely(!blocks)) {
+                                                unlink(entry->scheduled);
+                                                gsnedf_job_arrival(entry->scheduled);
+                                                /* we may regain the processor */
+                                                if (preempt) {
+                                                        preempt = entry->scheduled != entry->linked;
+                                                        if (!preempt) {
+                                                                TRACE_TASK(entry->scheduled, "blocked preemption by lazy boosting.\n");
+                                                        }
+                                                }
+                                        }
+                                }
                         }
-                }
-                else if (is_pgm_satisfied(entry->scheduled)) {
-                        TRACE_TASK(entry->scheduled, "is done waiting for PGM tokens.\n");
-                        BUG_ON(!is_priority_boosted(entry->scheduled));
-
-                        /* clear any boosting */
-                        tsk_rt(entry->scheduled)->priority_boosted = 0;
-                        setup_pgm_release(entry->scheduled);
-
-                        if (likely(!blocks)) {
-                                /* Task has probably called sched_yield(), so blocking is
-                                   unlikely. Re-evaluate scheduling decisions because we
-                                   still want to run. */
-                                unlink(entry->scheduled);
-                                gsnedf_job_arrival(entry->scheduled);
+                        else { /* sending is satisfied */
+                                tsk_rt(entry->scheduled)->ctrl_page->pgm_sending = 0;
+                                tsk_rt(entry->scheduled)->ctrl_page->pgm_satisfied = 0;
+
+                                if (is_priority_boosted(entry->scheduled)) {
+                                        TRACE_TASK(entry->scheduled,
+                                                        "is done sending PGM tokens must relinquish boosting.\n");
+                                        /* clear boosting */
+                                        tsk_rt(entry->scheduled)->priority_boosted = 0;
+                                        if(likely(!blocks)) {
+                                                /* recheck priority */
+                                                unlink(entry->scheduled);
+                                                gsnedf_job_arrival(entry->scheduled);
+                                                /* we may lose the processor */
+                                                if (!preempt) {
+                                                        preempt = entry->scheduled != entry->linked;
+                                                        if (preempt) {
+                                                                TRACE_TASK(entry->scheduled, "preempted by lazy unboosting.\n");
+                                                        }
+                                                }
+                                        }
+                                }
                         }
                 }
         }
@@ -509,10 +531,13 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
          * that we are still linked. Multiple calls to request_exit_np() don't
          * hurt.
          */
-        if (np && (out_of_time || preempt || sleep)) {
+        if (np && (out_of_time || sleep)) {
                 unlink(entry->scheduled);
                 request_exit_np(entry->scheduled);
         }
+        else if (np && preempt) {
+                request_exit_np(entry->scheduled);
+        }
 
         /* Any task that is preemptable and either exhausts its execution
          * budget or wants to sleep completes. We may have to reschedule after
@@ -543,12 +568,14 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
                         entry->scheduled->rt_param.scheduled_on = NO_CPU;
                         TRACE_TASK(entry->scheduled, "scheduled_on = NO_CPU\n");
                 }
-        } else
+        }
+        else {
                 /* Only override Linux scheduler if we have a real-time task
                  * scheduled that needs to continue.
                  */
                 if (exists)
                         next = prev;
+        }
 
         sched_state_task_picked();
 
@@ -563,7 +590,6 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
                 TRACE("becomes idle at %llu.\n", litmus_clock());
 #endif
 
-
         return next;
 }
 
@@ -635,6 +661,10 @@ static void gsnedf_task_wake_up(struct task_struct *task)
                 release_at(task, now);
                 sched_trace_task_release(task);
         }
+        if (is_pgm_waiting(task)) {
+                /* shift out release/deadline, if needed */
+                setup_pgm_release(task);
+        }
         gsnedf_job_arrival(task);
         raw_spin_unlock_irqrestore(&gsnedf_lock, flags);
 }