Differentiate between PERIODIC and SPORADIC tasks.

Tasks can now be PERIODIC or SPORADIC.

PERIODIC tasks do not have their job number incremented
when they wake up and are tardy. PERIODIC jobs must
end with a call to sys_complete_job() to set up their next
release. (Not currently supported by pfair.)

SPORADIC tasks _do_ have their job number incremented when
they wake up and are tardy. SPORADIC is the default task
behavior, carrying forward Litmus's current behavior.

7 files changed, 26 insertions, 20 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index 81f6a499570..c9206adb349 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -56,6 +56,7 @@ void litmus_exit_task(struct task_struct *tsk);
 #define get_partition(t)        (tsk_rt(t)->task_params.cpu)
 #define get_priority(t)         (tsk_rt(t)->task_params.priority)
 #define get_class(t)        (tsk_rt(t)->task_params.cls)
+#define get_release_policy(t) (tsk_rt(t)->task_params.release_policy)
 
 /* job_param macros */
 #define get_exec_time(t)    (tsk_rt(t)->job_params.exec_time)
@@ -63,10 +64,13 @@ void litmus_exit_task(struct task_struct *tsk);
 #define get_release(t)          (tsk_rt(t)->job_params.release)
 #define get_lateness(t)         (tsk_rt(t)->job_params.lateness)
 
+/* release policy macros */
+#define is_periodic(t)          (get_release_policy(t) == PERIODIC)
+#define is_sporadic(t)          (get_release_policy(t) == SPORADIC)
 #ifdef CONFIG_ALLOW_EARLY_RELEASE
-#define wants_early_release(t) (tsk_rt(t)->task_params.release_policy == EARLY)
+#define is_early_releasing(t)   (get_release_policy(t) == EARLY)
 #else
-#define wants_early_release(t) (0)
+#define is_early_releasing(t)   (0)
 #endif
 
 #define is_hrt(t)               \
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 4167508d986..a16ac84d804 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -33,19 +33,21 @@ typedef enum {
         PRECISE_ENFORCEMENT  /* budgets are enforced with hrtimers */
 } budget_policy_t;
 
+/* Release behaviors for jobs. PERIODIC and EARLY jobs
+   must end by calling sys_complete_job() (or equivalent)
+   to set up their next release and deadline. */
 typedef enum {
+        /* Jobs are released sporadically (provided job precedence
+       constraints are met). */
+        SPORADIC,
+
         /* Jobs are released periodically (provided job precedence
        constraints are met). */
         PERIODIC,
 
-        /* Jobs are released sporadically (provided job precedence
-       constraints are met). NOTE: Litmus currently does not
-       distinguish between periodic and sporadic tasks. */
-        SPORADIC = PERIODIC,
-
-    /* Jobs are released immediatly after meeting precedence
+    /* Jobs are released immediately after meeting precedence
        constraints. Beware this can peg your CPUs if used in
-       the wrong applications. */
+       the wrong applications. Only supported by EDF schedulers. */
         EARLY
 } release_policy_t;
 
@@ -78,7 +80,7 @@ struct rt_task {
         unsigned int    priority;
         task_class_t    cls;
         budget_policy_t  budget_policy;  /* ignored by pfair */
-        release_policy_t release_policy; /* ignored by non-edf */
+        release_policy_t release_policy;
 };
 
 union np_flag {
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index ba3ed452542..6e1327bbf50 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -254,7 +254,7 @@ static noinline void requeue(struct task_struct* task)
         /* sanity check before insertion */
         BUG_ON(is_queued(task));
 
-        if (wants_early_release(task) || is_released(task, litmus_clock()))
+        if (is_early_releasing(task) || is_released(task, litmus_clock()))
                 __add_ready(&cluster->domain, task);
         else {
                 /* it has got to wait */
@@ -353,7 +353,7 @@ static noinline void job_completion(struct task_struct *t, int forced)
         tsk_rt(t)->completed = 1;
         /* prepare for next period */
         prepare_for_next_period(t);
-        if (wants_early_release(t) || is_released(t, litmus_clock()))
+        if (is_early_releasing(t) || is_released(t, litmus_clock()))
                 sched_trace_task_release(t);
         /* unlink */
         unlink(t);
@@ -596,7 +596,7 @@ static void cedf_task_wake_up(struct task_struct *task)
 
         raw_spin_lock_irqsave(&cluster->cluster_lock, flags);
         now = litmus_clock();
-        if (is_tardy(task, now)) {
+        if (is_sporadic(task) && is_tardy(task, now)) {
                 /* new sporadic release */
                 release_at(task, now);
                 sched_trace_task_release(task);
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index ac5c4d83601..5956978ccdb 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -251,7 +251,7 @@ static noinline void requeue(struct task_struct* task)
         /* sanity check before insertion */
         BUG_ON(is_queued(task));
 
-        if (wants_early_release(task) || is_released(task, litmus_clock()))
+        if (is_early_releasing(task) || is_released(task, litmus_clock()))
                 __add_ready(&gsnedf, task);
         else {
                 /* it has got to wait */
@@ -344,7 +344,7 @@ static noinline void job_completion(struct task_struct *t, int forced)
         tsk_rt(t)->completed = 1;
         /* prepare for next period */
         prepare_for_next_period(t);
-        if (wants_early_release(t) || is_released(t, litmus_clock()))
+        if (is_early_releasing(t) || is_released(t, litmus_clock()))
                 sched_trace_task_release(t);
         /* unlink */
         unlink(t);
@@ -578,7 +578,7 @@ static void gsnedf_task_wake_up(struct task_struct *task)
 
         raw_spin_lock_irqsave(&gsnedf_lock, flags);
         now = litmus_clock();
-        if (is_tardy(task, now)) {
+        if (is_sporadic(task) && is_tardy(task, now)) {
                 /* new sporadic release */
                 release_at(task, now);
                 sched_trace_task_release(task);
diff --git a/litmus/sched_pfair.c b/litmus/sched_pfair.c
index 6a89b003306..d5fb3a832ad 100644
--- a/litmus/sched_pfair.c
+++ b/litmus/sched_pfair.c
@@ -710,7 +710,7 @@ static void pfair_task_wake_up(struct task_struct *t)
          */
         requeue = tsk_rt(t)->flags == RT_F_REQUEUE;
         now = litmus_clock();
-        if (lt_before(get_deadline(t), now)) {
+        if (is_tardy(t, now)) {
                 TRACE_TASK(t, "sporadic release!\n");
                 release_at(t, now);
                 prepare_release(t, time2quanta(now, CEIL));
diff --git a/litmus/sched_pfp.c b/litmus/sched_pfp.c
index fc9a509f185..aade0904491 100644
--- a/litmus/sched_pfp.c
+++ b/litmus/sched_pfp.c
@@ -343,7 +343,7 @@ static void pfp_task_wake_up(struct task_struct *task)
         BUG_ON(is_queued(task));
 #endif
         now = litmus_clock();
-        if (is_tardy(task, now)
+        if (is_sporadic(task) && is_tardy(task, now)
 #ifdef CONFIG_LITMUS_LOCKING
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 316333460dd..65c85a3a4c6 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -61,7 +61,7 @@ static void requeue(struct task_struct* t, rt_domain_t *edf)
                 TRACE_TASK(t, "requeue: !TASK_RUNNING\n");
 
         tsk_rt(t)->completed = 0;
-        if (wants_early_release(t) || is_released(t, litmus_clock()))
+        if (is_early_releasing(t) || is_released(t, litmus_clock()))
                 __add_ready(edf, t);
         else
                 add_release(edf, t); /* it has got to wait */
@@ -320,7 +320,7 @@ static void psnedf_task_wake_up(struct task_struct *task)
         raw_spin_lock_irqsave(&pedf->slock, flags);
         BUG_ON(is_queued(task));
         now = litmus_clock();
-        if (is_tardy(task, now)
+        if (is_sporadic(task) && is_tardy(task, now)
 #ifdef CONFIG_LITMUS_LOCKING
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring