Port C-FL PGM algorithms to C-EDF.

1 files changed, 25 insertions, 24 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index ca4cd0c1d3f0..33ea89e81eff 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -456,9 +456,10 @@ static struct task_struct* cedf_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);
@@ -473,17 +474,24 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
 
                                         /* We are either sending tokens or waiting for tokes.
                                            If waiting: Boost priority so we'll be scheduled
-                                             immediately when needed tokens arrive.
+                                                immediately when needed tokens arrive.
                                            If sending: Boost priority so no one (specifically, our
-                                             consumers) will preempt us while signalling the token
-                                             transmission.
-                                         */
+                                                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);
+                                                /* we may regain the processor */
+                                                if (preempt) {
+                                                        preempt = entry->scheduled != entry->linked;
+                                                        if (!preempt) {
+                                                                TRACE_TASK(entry->scheduled, "blocked preemption by lazy boosting.\n");
+                                                        }
+                                                }
                                         }
                                 }
                         }
@@ -500,26 +508,17 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                                                 /* recheck priority */
                                                 unlink(entry->scheduled);
                                                 cedf_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");
+                                                        }
+                                                }
                                         }
                                 }
                         }
                 }
-#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
 
@@ -533,10 +532,13 @@ static struct task_struct* cedf_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
@@ -586,7 +588,6 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                 TRACE("becomes idle at %llu.\n", litmus_clock());
 #endif
 
-
         return next;
 }