GSN-EDF: Make sleep_next_period() a no-op if already completed due to budget exhaustion

Vanilla LITMUS-RT (without reservations) does not distinguish between
a period which voluntarily ends (via the complete_job() userspace call)
and a period which is forced to complete due to budget exhaustion.

This results in inconsistent behavior of the userspace API when budget
enforcement is enabled. Say a task's budget is set slightly below its actual
execution time. In this case, the task is suspended during its first job by
budget enforcement. When the second period starts, the task immediately
completes it's work and calls sleep_next_period(). From the perspective of
the task, it should enter its second job after calling sleep_next_period().
From the perspective of LITMUS-RT, the task is already in its second
period and will suspend the task until its _third_ period. This patch fixes
that bug for GSN-EDF by only suspending the task on
sleep_next_period() if the previous period was not force-completed by
budget enforcement.

1 files changed, 24 insertions, 2 deletions

diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 76095cdb09a0..d4013aed6196 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -125,6 +125,9 @@ static struct bheap      gsnedf_cpu_heap;
 static rt_domain_t gsnedf;
 #define gsnedf_lock (gsnedf.ready_lock)
 
+/* use the untouched rt_params->plugin_state as the forced completion bit */
+#define get_forced_completion(t) t->rt_param.plugin_state
+#define set_forced_completion(t, forced) t->rt_param.plugin_state = forced
 
 /* Uncomment this if you want to see all scheduling decisions in the
  * TRACE() log.
@@ -474,8 +477,27 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
          * this. Don't do a job completion if we block (can't have timers running
          * for blocked jobs).
          */
-        if (!np && (out_of_time || sleep))
-                curr_job_completion(!sleep);
+        if (!np && (out_of_time || sleep)) {
+                if(sleep && get_forced_completion(entry->scheduled)) {
+                        /* if we have a forced completion just before, simply
+                         * set the completed flag to 0
+                         */
+                        TRACE_TASK(entry->scheduled,
+                                   "Task should complete normally, "
+                                   "but skipped due to a previous forced completion "
+                                   "caused by budget overrun\n");
+                        /* used current as in curr_job_completion */
+                        tsk_rt(current)->completed = 0;
+                } else {
+                        /* if we have a forced completion now or a normal
+                         * completion without previous forced completion,
+                         * simply call curr_job_completion
+                         */
+                        curr_job_completion(!sleep);
+                }
+                /* record whether there is a forced completion */
+                set_forced_completion(entry->scheduled, out_of_time);
+        }
 
         /* Link pending task if we became unlinked.
          */