PGM: Boost priority of producers, not consumers.

This patch boosts the priority of PGM producers while
they are sending tokens instead of boosting the priority
of consumers while they are waiting for tokens. This improves
schedulability analysis.

1 files changed, 54 insertions, 27 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 95b2dc3bea55..c39b8ee407c7 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -464,39 +464,62 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                            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);
-                                cedf_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);
+                                                cedf_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);
+                                                cedf_job_arrival(entry->scheduled);
+                                        }
+                                }
                         }
                 }
-                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. */
+#if 0
+                else if(is_pgm_waiting(entry->scheduled)) {
+                        int shifted_release;
+
+                        TRACE_TASK(entry->scheduled, "is waiting for PGM tokens.\n");
+                        /* release the next job if we have the tokens we need */
+                        shifted_release = setup_pgm_release(entry->scheduled);
+
+                        /* setup_pgm_release() can screw with our priority,
+                           so recheck it */
+                        if (shifted_release && likely(!blocks)) {
                                 unlink(entry->scheduled);
                                 cedf_job_arrival(entry->scheduled);
                         }
                 }
+#endif
         }
 #endif
 
@@ -641,6 +664,10 @@ static void cedf_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);
+        }
         cedf_job_arrival(task);
         raw_spin_unlock_irqrestore(&cluster->cluster_lock, flags);
 }