1 files changed, 74 insertions, 3 deletions

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);