PGM supportwip-mc2-new

1 files changed, 74 insertions, 2 deletions

diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index a310723dce24..9ed92d355d7a 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -25,6 +25,7 @@
 #include <litmus/mc2_common.h>
 #include <litmus/reservation.h>
 #include <litmus/polling_reservations.h>
+#include <litmus/pgm.h>
 
 #define BUDGET_ENFORCEMENT_AT_C 0
 
@@ -614,14 +615,82 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         /* next == NULL means "schedule background work". */
         lt_t now;
         struct mc2_cpu_state *state = local_cpu_state();
+        int sleep, preempt, np, exists, blocks;
 
         pre_schedule(prev, state->cpu);
         
         raw_spin_lock(&_global_env.lock);
         raw_spin_lock(&state->lock);
         
-        //BUG_ON(state->scheduled && state->scheduled != prev);
-        //BUG_ON(state->scheduled && !is_realtime(prev));
+        /* sanity check */
+        BUG_ON(state->scheduled && state->scheduled != prev);
+        BUG_ON(state->scheduled && !is_realtime(prev));
+        BUG_ON(is_realtime(prev) && !state->scheduled);
+
+        /* (0) Determine state */
+        exists          = state->scheduled != NULL;
+        blocks          = exists && !is_running(state->scheduled);
+        sleep           = exists && is_completed(state->scheduled);
+        np                      = exists && is_np(state->scheduled);    
+        preempt         = _lowest_prio_cpu.cpu_entries[state->cpu].will_schedule;
+    
+    if (exists) {
+        if (is_pgm_sending(state->scheduled)) {
+            if (!is_pgm_satisfied(state->scheduled)) {
+                if (!is_priority_boosted(state->scheduled)) {
+                    TRACE_TASK(state->scheduled, "is sending PGM tokens and needs boosting.\n");
+                    BUG_ON(is_pgm_satisfied(state->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(state->scheduled)->priority_boosted = 1;
+                    tsk_rt(state->scheduled)->boost_start_time = litmus_clock();
+
+                    if (likely(!blocks)) {
+                                                task_departs(state->scheduled, is_completed(prev));
+                        task_arrives(state, state->scheduled);
+                        /* we may regain the processor */
+                        if (preempt) {
+                            //preempt = resched_cpu[state->cpu];
+                                                        litmus_reschedule_local();
+                            if (!preempt) {
+                                TRACE_TASK(state->scheduled, "blocked preemption by lazy boosting.\n");
+                            }
+                        }
+                    }
+                }
+            }
+            else { /* sending is satisfied */
+                tsk_rt(state->scheduled)->ctrl_page->pgm_sending = 0;
+                tsk_rt(state->scheduled)->ctrl_page->pgm_satisfied = 0;
+
+                if (is_priority_boosted(state->scheduled)) {
+                    TRACE_TASK(state->scheduled,
+                            "is done sending PGM tokens must relinquish boosting.\n");
+                    /* clear boosting */
+                    tsk_rt(state->scheduled)->priority_boosted = 0;
+                    if(likely(!blocks)) {
+                        /* recheck priority */
+                                                task_departs(state->scheduled, is_completed(prev));
+                        task_arrives(state, state->scheduled);
+                        /* we may lose the processor */
+                        if (!preempt) {
+                            //preempt = resched_cpu[state->cpu];
+                                                        litmus_reschedule_local();
+                            if (preempt) {
+                                TRACE_TASK(state->scheduled, "preempted by lazy unboosting.\n");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
 
         /* update time */
         state->sup_env.will_schedule = true;
@@ -701,6 +770,9 @@ static void resume_legacy_task_model_updates(struct task_struct *tsk)
                         sched_trace_task_release(tsk);
                 }
         }
+        //if (is_pgm_waiting(tsk)) {
+        //      setup_pgm_release(tsk);
+        //}
 }
 
 /* mc2_task_resume - Called when the state of tsk changes back to