GEDF, PEDF, and PFP: fixed budget hooks

5 files changed, 63 insertions, 61 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index e8de5dd18b7f..1bfdef17e519 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -860,7 +860,7 @@ static void cedf_tick(struct task_struct* t)
         if (is_realtime(t) &&
                 tsk_rt(t)->budget.ops && budget_quantum_tracked(t) &&
                 budget_exhausted(t)) {
-                        TRACE_TASK(t, "budget exhausted\n");
+                TRACE_TASK(t, "budget exhausted\n");
                 budget_state_machine(t,on_exhausted);
         }
 }
@@ -1499,8 +1499,7 @@ static void cedf_task_exit(struct task_struct * t)
 
         /* disable budget enforcement */
         cedf_untrack_in_top_m(t);
-        if (tsk_rt(t)->budget.ops)
-                budget_state_machine(t,on_exit);
+        budget_state_machine(t,on_exit);
 
 #ifdef CONFIG_REALTIME_AUX_TASKS
         /* make sure we clean up on our way out */
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 3084f377a5f1..cad6210d844d 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -462,7 +462,7 @@ static void gsnedf_tick(struct task_struct* t)
                 tsk_rt(t)->budget.ops && budget_quantum_tracked(t) &&
                 budget_exhausted(t)) {
                 TRACE_TASK(t, "budget exhausted\n");
-                tsk_rt(t)->budget.ops->on_exhausted(t);
+                budget_state_machine(t,on_exhausted);
         }
 }
 
@@ -848,14 +848,12 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
                            entry->linked->comm, entry->linked->pid);
 
         /* Do budget stuff */
-        if (tsk_rt(prev)->budget.ops) {
-                if (blocks)
-                        tsk_rt(prev)->budget.ops->on_blocked(prev);
-                else if (sleep)
-                        tsk_rt(prev)->budget.ops->on_sleep(prev);
-                else if (preempt)
-                        tsk_rt(prev)->budget.ops->on_preempt(prev);
-        }
+        if (blocks)
+                budget_state_machine(prev,on_blocked);
+        else if (sleep)
+                budget_state_machine(prev,on_sleep);
+        else if (preempt)
+                budget_state_machine(prev,on_preempt);
 
         /* If a task blocks we have no choice but to reschedule.
          */
@@ -1001,13 +999,12 @@ static void gsnedf_task_new(struct task_struct * t, int on_rq, int running)
 static void gsnedf_task_wake_up(struct task_struct *task)
 {
         unsigned long flags;
-        //lt_t now;
+        lt_t now;
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
 
         raw_readyq_lock_irqsave(&gsnedf_lock, flags);
 
-#if 0
         /* sporadic task model. will increment job numbers automatically */
         now = litmus_clock();
         if (is_sporadic(task) && is_tardy(task, now)) {
@@ -1016,16 +1013,8 @@ static void gsnedf_task_wake_up(struct task_struct *task)
                 sched_trace_task_release(task);
         }
         else {
-                if (task->rt.time_slice) {
-                        /* came back in time before deadline
-                        */
-                        tsk_rt(task)->completed = 0;
-                }
+                tsk_rt(task)->completed = 0;
         }
-#else
-        /* don't force job to end.  rely on user to say when jobs complete */
-        tsk_rt(task)->completed = 0;
-#endif
 
 #ifdef CONFIG_REALTIME_AUX_TASKS
         if (tsk_rt(task)->has_aux_tasks && !tsk_rt(task)->hide_from_aux_tasks) {
@@ -1041,6 +1030,8 @@ static void gsnedf_task_wake_up(struct task_struct *task)
         }
 #endif
 
+        budget_state_machine(task,on_wakeup);
+
         gsnedf_job_arrival(task);
         raw_readyq_unlock_irqrestore(&gsnedf_lock, flags);
 }
@@ -1090,8 +1081,7 @@ static void gsnedf_task_exit(struct task_struct * t)
         raw_readyq_lock_irqsave(&gsnedf_lock, flags);
 
         /* disable budget enforcement */
-        if (tsk_rt(t)->budget.ops)
-                tsk_rt(t)->budget.ops->on_exit(t);
+        budget_state_machine(t,on_exit);
 
 #ifdef CONFIG_REALTIME_AUX_TASKS
         /* make sure we clean up on our way out */
@@ -1181,10 +1171,16 @@ static int __increase_priority_inheritance(struct task_struct* t,
         /* this sanity check allows for weaker locking in protocols */
         if(__edf_higher_prio(prio_inh, BASE, t, EFFECTIVE)) {
 #endif
+                if (tsk_rt(t)->inh_task)
+                        budget_state_machine2(t,tsk_rt(t)->inh_task,on_disinherit);
+
                 TRACE_TASK(t, "inherits priority from %s/%d\n",
                                    prio_inh->comm, prio_inh->pid);
                 tsk_rt(t)->inh_task = prio_inh;
 
+                if (prio_inh)
+                        budget_state_machine2(t,prio_inh,on_inherit);
+
                 linked_on  = tsk_rt(t)->linked_on;
 
                 /* If it is scheduled, then we need to reorder the CPU heap. */
@@ -1312,6 +1308,10 @@ static int __decrease_priority_inheritance(struct task_struct* t,
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         if(budget_triggered || __edf_higher_prio(t, EFFECTIVE, prio_inh, BASE)) {
 #endif
+
+                if (tsk_rt(t)->inh_task)
+                        budget_state_machine2(t,tsk_rt(t)->inh_task,on_disinherit);
+
                 /* A job only stops inheriting a priority when it releases a
                  * resource. Thus we can make the following assumption.*/
                 if(prio_inh)
@@ -1322,6 +1322,9 @@ static int __decrease_priority_inheritance(struct task_struct* t,
 
                 tsk_rt(t)->inh_task = prio_inh;
 
+                if (prio_inh)
+                        budget_state_machine2(t,prio_inh,on_inherit);
+
                 if(tsk_rt(t)->scheduled_on != NO_CPU) {
                         TRACE_TASK(t, "is scheduled.\n");
 
diff --git a/litmus/sched_pfair.c b/litmus/sched_pfair.c
index 707e6b6f2483..a7281348fd97 100644
--- a/litmus/sched_pfair.c
+++ b/litmus/sched_pfair.c
@@ -848,16 +848,6 @@ static void dump_subtasks(struct task_struct* t)
                            t->rt_param.pfair->subtasks[i].group_deadline);
 }
 
-static struct budget_tracker_ops pfair_drain_simple_ops =
-{
-        .on_scheduled = simple_on_scheduled,
-        .on_blocked = simple_on_blocked,
-        .on_preempt_or_sleep = simple_on_preempt_or_sleep,
-        .on_exit = simple_on_exit,
-
-        .on_exhausted = pfair_simple_on_exhausted,
-};
-
 static long pfair_admit_task(struct task_struct* t)
 {
         lt_t quanta;
@@ -925,6 +915,14 @@ static long pfair_admit_task(struct task_struct* t)
 
         t->rt_param.pfair = param;
 
+        if (budget_enforced(t) || budget_signalled(t)) {
+                switch(get_drain_policy(t)) {
+                        default:
+                                TRACE_TASK(t, "Unsupported budget draining mode.\n");
+                                return -EINVAL;
+                }
+        }
+
         /* spew out some debug info */
         dump_subtasks(t);
 
diff --git a/litmus/sched_pfp.c b/litmus/sched_pfp.c
index ad2b8d81f29f..891469054ab4 100644
--- a/litmus/sched_pfp.c
+++ b/litmus/sched_pfp.c
@@ -175,7 +175,7 @@ static void pfp_tick(struct task_struct *t)
                 tsk_rt(t)->budget.ops && budget_quantum_tracked(t) &&
                 budget_exhausted(t)) {
                 TRACE_TASK(t, "budget exhausted\n");
-                tsk_rt(t)->budget.ops->on_exhausted(t);
+                budget_state_machine(t,on_exhausted);
         }
 }
 
@@ -213,14 +213,12 @@ static struct task_struct* pfp_schedule(struct task_struct * prev)
         resched = preempt;
 
         /* Do budget stuff */
-        if (tsk_rt(prev)->budget.ops) {
-                if (blocks)
-                        tsk_rt(prev)->budget.ops->on_blocked(prev);
-                else if (sleep)
-                        tsk_rt(prev)->budget.ops->on_sleep(prev);
-                else if (preempt)
-                        tsk_rt(prev)->budget.ops->on_preempt(prev);
-        }
+        if (blocks)
+                budget_state_machine(prev,on_blocked);
+        else if (sleep)
+                budget_state_machine(prev,on_sleep);
+        else if (preempt)
+                budget_state_machine(prev,on_preempt);
 
         /* If a task blocks we have no choice but to reschedule.
          */
@@ -389,6 +387,8 @@ static void pfp_task_wake_up(struct task_struct *task)
                 sched_trace_task_release(task);
         }
 
+        budget_state_machine(task,on_wakeup);
+
         /* Only add to ready queue if it is not the currently-scheduled
          * task. This could be the case if a task was woken up concurrently
          * on a remote CPU before the executing CPU got around to actually
@@ -436,8 +436,7 @@ static void pfp_task_exit(struct task_struct * t)
         raw_readyq_lock_irqsave(&pfp->slock, flags);
 
         /* disable budget enforcement */
-        if (tsk_rt(t)->budget.ops)
-                tsk_rt(t)->budget.ops->on_exit(t);
+        budget_state_machine(t,on_exit);
 
         if (is_queued(t)) {
                 BUG(); /* This currently doesn't work. */
@@ -485,8 +484,14 @@ static void fp_set_prio_inh(pfp_domain_t* pfp, struct task_struct* t,
                 /* first remove */
                 fp_dequeue(pfp, t);
 
+        if (t->rt_param.inh_task)
+                budget_state_machine2(t,t->rt_param.inh_task,on_disinherit);
+
         t->rt_param.inh_task = prio_inh;
 
+        if (prio_inh)
+                budget_state_machine2(t,prio_inh,on_inherit);
+
         if (requeue)
                 /* add again to the right queue */
                 fp_prio_add(&pfp->ready_queue, t, priority_index(t));
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index dffaeb425abf..b8246acacaa9 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -179,12 +179,10 @@ static enum hrtimer_restart psnedf_simple_on_exhausted(struct task_struct *t)
                          * preemptable again
                          */
                         litmus_reschedule_local();
-                        TRACE("cedf_scheduler_tick: "
-                                  "%d is preemptable "
+                        TRACE("%d is preemptable "
                                   " => FORCE_RESCHED\n", t->pid);
                 } else if (is_user_np(t)) {
-                        TRACE("cedf_scheduler_tick: "
-                                  "%d is non-preemptable, "
+                        TRACE("%d is non-preemptable, "
                                   "preemption delayed.\n", t->pid);
                         request_exit_np(t);
                 }
@@ -207,7 +205,7 @@ static void psnedf_tick(struct task_struct *t)
                 tsk_rt(t)->budget.ops && budget_quantum_tracked(t) &&
                 budget_exhausted(t)) {
                 TRACE_TASK(t, "budget exhausted\n");
-                tsk_rt(t)->budget.ops->on_exhausted(t);
+                budget_state_machine(t,on_exhausted);
         }
 }
 
@@ -245,14 +243,12 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
         resched = preempt;
 
         /* Do budget stuff */
-        if (tsk_rt(prev)->budget.ops) {
-                if (blocks)
-                        tsk_rt(prev)->budget.ops->on_blocked(prev);
-                else if (sleep)
-                        tsk_rt(prev)->budget.ops->on_sleep(prev);
-                else if (preempt)
-                        tsk_rt(prev)->budget.ops->on_preempt(prev);
-        }
+        if (blocks)
+                budget_state_machine(prev,on_blocked);
+        else if (sleep)
+                budget_state_machine(prev,on_sleep);
+        else if (preempt)
+                budget_state_machine(prev,on_preempt);
 
         /* If a task blocks we have no choice but to reschedule.
          */
@@ -365,6 +361,8 @@ static void psnedf_task_wake_up(struct task_struct *task)
                 sched_trace_task_release(task);
         }
 
+        budget_state_machine(task,on_wakeup);
+
         /* Only add to ready queue if it is not the currently-scheduled
          * task. This could be the case if a task was woken up concurrently
          * on a remote CPU before the executing CPU got around to actually
@@ -398,8 +396,7 @@ static void psnedf_task_exit(struct task_struct * t)
         raw_readyq_lock_irqsave(&pedf->slock, flags);
 
         /* disable budget enforcement */
-        if (tsk_rt(t)->budget.ops)
-                tsk_rt(t)->budget.ops->on_exit(t);
+        budget_state_machine(t,on_exit);
 
         if (is_queued(t)) {
                 /* dequeue */