5 files changed, 179 insertions, 4 deletions

diff --git a/litmus/Makefile b/litmus/Makefile
index 3d0de72284f8..c19b6015b02e 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -40,3 +40,4 @@ obj-y += reservation.o polling_reservations.o
 
 obj-y += sched_pres.o
 obj-y += mc2_common.o sched_mc2.o
+obj-y += pgm.o
diff --git a/litmus/litmus.c b/litmus/litmus.c
index d72039067689..d2815f52876e 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -140,10 +140,16 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param)
         if (tp.relative_deadline == 0)
                 tp.relative_deadline = tp.period;
 
-        if (tp.exec_cost <= 0)
+        if (tp.exec_cost <= 0) {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                        "because declared job execution time <= 0.", pid);
                 goto out_unlock;
-        if (tp.period <= 0)
+        }
+        if (tp.period <= 0) {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                                "because declared job period <= 0.", pid);
                 goto out_unlock;
+        }
         if (min(tp.relative_deadline, tp.period) < tp.exec_cost) /*density check*/
         {
                 printk(KERN_INFO "litmus: real-time task %d rejected "
@@ -169,6 +175,13 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param)
                 goto out_unlock;
         }
 
+        if (tp.pgm_type < PGM_NOT_A_NODE || tp.pgm_type > PGM_INTERNAL) {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                           "because of unknown PGM node type specified (%d)\n",
+                           pid, tp.pgm_type);
+                goto out_unlock;
+        }
+
         target->rt_param.task_params = tp;
 
         retval = 0;
@@ -549,6 +562,10 @@ long litmus_admit_task(struct task_struct* tsk)
         if (get_rt_relative_deadline(tsk) == 0 ||
             get_exec_cost(tsk) >
                         min(get_rt_relative_deadline(tsk), get_rt_period(tsk)) ) {
+                printk(KERN_INFO "litmus: invalid task parameters "
+                        "(e = %lu, p = %lu, d = %lu)\n",
+                        get_exec_cost(tsk), get_rt_period(tsk),
+                        get_rt_relative_deadline(tsk));
                 TRACE_TASK(tsk,
                         "litmus admit: invalid task parameters "
                         "(e = %lu, p = %lu, d = %lu)\n",
@@ -580,6 +597,7 @@ long litmus_admit_task(struct task_struct* tsk)
         if (!retval) {
                 sched_trace_task_name(tsk);
                 sched_trace_task_param(tsk);
+                sched_trace_pgm_param(tsk);
                 atomic_inc(&rt_task_count);
         }
 
diff --git a/litmus/pgm.c b/litmus/pgm.c
new file mode 100644
index 000000000000..db3378ff803d
--- /dev/null
+++ b/litmus/pgm.c
@@ -0,0 +1,61 @@
+/* litmus/pgm.c - common pgm control code
+ */
+
+#include <linux/sched.h>
+#include <litmus/litmus.h>
+#include <litmus/pgm.h>
+#include <litmus/sched_trace.h>
+
+/* Only readjust release/deadline if difference is over a given threshold.
+   It's a weak method for accounting overheads. Ideally, we'd know the last
+   time t was woken up by its last predecessor, rather than having to look
+   at 'now'. Adjustment threshold currently set to 200us. */
+#define ADJUSTMENT_THRESH_NS (200*1000LL)
+
+int setup_pgm_release(struct task_struct* t)
+{
+        int shifted_release = 0;
+
+        /* approximate time last predecessor gave us tokens */
+        lt_t now = litmus_clock();
+
+        TRACE_TASK(t, "is starting a new PGM job: waiting:%d\n",
+                tsk_rt(t)->ctrl_page->pgm_waiting);
+
+        BUG_ON(!tsk_rt(t)->ctrl_page->pgm_waiting);
+
+        /* Adjust release time if we got the last tokens after release of this job.
+           This is possible since PGM jobs are early-released. Don't shift our
+           deadline if we got the tokens earlier than expected. */
+        if (now > tsk_rt(t)->job_params.release) {
+                long long diff_ns = now - tsk_rt(t)->job_params.release;
+                if (diff_ns > ADJUSTMENT_THRESH_NS) {
+                        lt_t adj_deadline = now + get_rt_relative_deadline(t);
+
+                        TRACE_TASK(t, "adjusting PGM release time from (r = %llu, d = %llu) "
+                                "to (r = %llu, d = %llu)\n",
+                                tsk_rt(t)->job_params.release, tsk_rt(t)->job_params.deadline,
+                                now, adj_deadline);
+
+                        tsk_rt(t)->job_params.release = now;
+                        tsk_rt(t)->job_params.deadline = adj_deadline;
+                        shifted_release = 1;
+                }
+                else {
+                        TRACE_TASK(t, "adjustment falls below threshold. %lld < %lld\n",
+                                diff_ns, ADJUSTMENT_THRESH_NS);
+                }
+        }
+        else {
+                TRACE_TASK(t, "got tokens early--no need to adjust release. "
+                        "cur time = %llu, release time = %llu\n",
+                        now, tsk_rt(t)->job_params.release);
+        }
+
+        /* possible that there can be multiple instances of pgm_release logged.
+           analysis tools should filter out all but the last pgm_release for
+           a given job release */
+        sched_trace_pgm_release(t);
+
+        return shifted_release;
+}
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 
diff --git a/litmus/sched_task_trace.c b/litmus/sched_task_trace.c
index 3a6756deb32f..784b18ecfd8b 100644
--- a/litmus/sched_task_trace.c
+++ b/litmus/sched_task_trace.c
@@ -238,3 +238,26 @@ feather_callback void do_sched_trace_action(unsigned long id,
                 put_record(rec);
         }
 }
+
+feather_callback void do_sched_trace_pgm_param(unsigned long id, unsigned long _task)
+{
+        struct task_struct *t = (struct task_struct*) _task;
+        struct st_event_record* rec = get_record(ST_PGM_PARAM, t);
+        if (rec) {
+                rec->data.pgm_param.node_type = tsk_rt(t)->task_params.pgm_type;
+                rec->data.pgm_param.graph_pid = t->tgid;
+                rec->data.pgm_param.expected_graph_etoe = tsk_rt(t)->task_params.pgm_expected_etoe;
+                put_record(rec);
+        }
+}
+
+feather_callback void do_sched_trace_pgm_release(unsigned long id, unsigned long _task)
+{
+        struct task_struct *t = (struct task_struct*) _task;
+        struct st_event_record* rec = get_record(ST_PGM_RELEASE, t);
+        if (rec) {
+                rec->data.pgm_release.release  = get_release(t);
+                rec->data.pgm_release.deadline = get_deadline(t);
+                put_record(rec);
+        }
+}