2 files changed, 79 insertions, 7 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index fc76f4361320..f0b7b1c54134 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -225,11 +225,12 @@ struct rt_param {
         /* runtime info for the semi-part plugins */
         union {
                 struct {
-                        /* how much time has the job received in the current
-                         * slice */
-                        lt_t slice_exec;
+                        /* at which exec time did the current slice start? */
+                        lt_t exec_time;
+                        /* cached job parameters */
+                        lt_t job_release, job_deadline;
                         /* pointer to the current slice */
-                        struct edf_wm_slice* wm_slice;
+                        struct edf_wm_slice* slice;
                 } wm;
         } semi_part;
 };
diff --git a/litmus/sched_edf_wm.c b/litmus/sched_edf_wm.c
index 324ca8f28ab7..0098a3aab5b5 100644
--- a/litmus/sched_edf_wm.c
+++ b/litmus/sched_edf_wm.c
@@ -41,6 +41,80 @@ DEFINE_PER_CPU(wm_domain_t, wm_domains);
 #define domain_of_task(task) (remote_domain(get_partition(task)))
 #define domain_from_timer(t) (container_of((t), wm_domain_t, enforcement_timer))
 
+static int is_sliced_task(struct task_struct* t)
+{
+        return tsk_rt(t)->task_params.semi_part.wm.count;
+}
+
+static void compute_slice_params(struct task_struct* t)
+{
+        struct rt_param* p = tsk_rt(t);
+        /* Here we do a little trick to make the generic EDF code
+         * play well with job slices. We overwrite the job-level
+         * release and deadline fields with the slice-specific values
+         * so that we can enqueue this task in an EDF rt_domain_t
+         * without issue. The actual values are cached in the semi_part.wm
+         * structure. */
+        p->job_params.deadline = p->semi_part.wm.job_release +
+                p->semi_part.wm.slice->deadline;
+        p->job_params.release  = p->semi_part.wm.job_release +
+                p->semi_part.wm.slice->offset;
+
+        /* Similarly, we play a trick on the cpu field. */
+        p->task_params.cpu = p->semi_part.wm.slice->cpu;
+
+        /* update the per-slice budget reference */
+        p->semi_part.wm.exec_time = p->job_params.exec_time;
+}
+
+static void complete_sliced_job(struct task_struct* t)
+{
+        struct rt_param* p = tsk_rt(t);
+
+        /* We need to undo our trickery to the
+         * job parameters (see above). */
+        p->job_params.release  = p->semi_part.wm.job_release;
+        p->job_params.deadline = p->semi_part.wm.job_deadline;
+
+        /* Ok, now let generic code do the actual work. */
+        prepare_for_next_period(t);
+
+        /* And finally cache the updated parameters. */
+        p->semi_part.wm.job_release = p->job_params.release;
+        p->semi_part.wm.job_deadline = p->job_params.deadline;
+}
+
+static void advance_next_slice(struct task_struct* t, int completion_signaled)
+{
+        int idx;
+        struct rt_param* p = tsk_rt(t);
+
+        /* make sure this is actually a sliced job */
+        BUG_ON(!is_sliced_task(t));
+
+        /* determine index of current slice */
+        idx = p->semi_part.wm.slice -
+                p->task_params.semi_part.wm.slices;
+
+        if (completion_signaled)
+                idx = 0;
+        else
+                /* increment and wrap around, if necessary */
+                idx = (idx + 1) % p->task_params.semi_part.wm.count;
+
+        /* point to next slice */
+        p->semi_part.wm.slice =
+                p->task_params.semi_part.wm.slices + idx;
+
+        /* Check if we need to update essential job parameters. */
+        if (!idx)
+                /* job completion */
+                complete_sliced_job(t);
+
+        /* Update job parameters for new slice. */
+        compute_slice_params(t);
+}
+
 /* we assume the lock is being held */
 static void preempt(wm_domain_t *dom)
 {
@@ -91,9 +165,6 @@ static void requeue(struct task_struct* t, rt_domain_t *edf)
                 add_release(edf, t); /* it has got to wait */
 }
 
-/* This check is trivial in partioned systems as we only have to consider
- * the CPU of the partition.
- */
 static int wm_check_resched(rt_domain_t *edf)
 {
         wm_domain_t *dom = container_of(edf, wm_domain_t, domain);