Integrated color chunking into the mc plugin.

2 files changed, 59 insertions, 15 deletions

diff --git a/litmus/jobs.c b/litmus/jobs.c
index fa55283e2134..d5556f547f6f 100644
--- a/litmus/jobs.c
+++ b/litmus/jobs.c
@@ -12,6 +12,10 @@
 #include <litmus/event_group.h>
 #endif
 
+#ifdef CONFIG_PLUGIN_COLOR
+#include <litmus/color.h>
+#endif
+
 #ifdef CONFIG_PLUGIN_MC
 #include <litmus/sched_mc.h>
 #else
@@ -32,15 +36,18 @@ static inline void setup_release(struct task_struct *t, struct rt_job *job,
 
 static inline void setup_kernel_release(struct task_struct *t, lt_t release)
 {
-        lt_t now = litmus_clock();
-
         BUG_ON(!t);
 
+#ifdef CONFIG_PLUGIN_COLOR
+        if (tsk_rt(t)->orig_cost)
+                get_exec_cost(t) = color_chunk;
+#endif
+
         /* Record lateness before we set up the next job's
          * release and deadline. Lateness may be negative.
          */
         t->rt_param.job_params.lateness =
-                (long long)now -
+                (long long)litmus_clock() -
                 (long long)t->rt_param.job_params.deadline;
 
         t->rt.time_slice = 1;
@@ -66,6 +73,29 @@ void setup_user_release(struct task_struct *t, lt_t release)
 
 void prepare_for_next_period(struct task_struct *t)
 {
+        lt_t rem, exec, orig;
+
+#ifdef CONFIG_PLUGIN_COLOR
+        if (tsk_rt(t)->orig_cost) {
+                /* Task is chunked */
+                tsk_rt(t)->last_exec_time += get_exec_time(t);
+
+                exec = tsk_rt(t)->last_exec_time;
+                orig = tsk_rt(t)->orig_cost;
+                rem  = orig - exec;
+
+                if (lt_before(exec, orig)) {
+                        /* Don't increment period if there is user-space work to
+                         * perform and we haven't exhausted our original budget
+                         */
+                        get_exec_time(t) = 0;
+                        /* The last chunk is a remainder */
+                        if (rem < get_exec_cost(t))
+                                get_exec_cost(t) = rem;
+                        return;
+                }
+        }
+#endif
         setup_kernel_release(t, get_release(t) + get_rt_period(t));
 }
 
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index b34ec4ee9e59..76479fd08d3a 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -336,7 +336,7 @@ static void link_task_to_crit(struct crit_entry *ce,
                 /* Block if task cannot acquire resources */
                 task->rt_param.linked_on = crit_cpu(ce)->cpu;
 
-                if (is_ghost(task) || ce->domain->acquire_resources(task))
+                if (ce->domain->acquire_resources(task))
                         start_crit(ce);
                 else
                         ce->state = CS_BLOCKED;
@@ -684,7 +684,6 @@ static void job_completion(struct task_struct *task, int forced)
 
         /* Logically stop the task execution */
         set_rt_flags(task, RT_F_SLEEP);
-        remove_from_all(task);
 
         if (!forced) {
                 /* Userspace signaled job completion */
@@ -716,9 +715,16 @@ static void job_completion(struct task_struct *task, int forced)
                 set_rt_flags(task, RT_F_RUNNING);
         }
 
-        /* Requeue non-blocking tasks */
-        if (is_running(task))
-                job_arrival(task);
+        /* If the server was not released, then the task's priority remains
+         * unchanged and it should be left where it is
+         */
+        if (release_server) {
+                remove_from_all(task);
+                if (is_running(task)) {
+                        /* Requeue non-blocking tasks */
+                        job_arrival(task);
+                }
+        }
 }
 
 /**
@@ -885,6 +891,21 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
                 entry = &per_cpu(cpus, task_cpu(t));
         t->rt_param._domain = entry->crit_entries[level].domain;
 
+        /* Userspace and kernelspace view of task state may differ.
+         * Model kernel state as an additional container
+         */
+        sched_trace_container_param(t->pid, t->comm);
+        sched_trace_server_param(-t->pid, t->pid,
+                                 get_exec_cost(t), get_rt_period(t));
+
+        /* Apply chunking */
+        if (level == CRIT_LEVEL_B) {
+                tsk_rt(t)->task_params.budget_policy = PRECISE_ENFORCEMENT;
+                if (color_chunk && level == CRIT_LEVEL_B &&
+                    lt_after(get_exec_cost(t), color_chunk))
+                        tsk_rt(t)->orig_cost = get_exec_cost(t);
+        }
+
         /* Setup color request */
         req = kmalloc(sizeof(*req), GFP_ATOMIC);
         req->task = t;
@@ -897,13 +918,6 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
                         set_req(&group_lock, req, ccp->colors[i], ccp->pages[i]);
         }
 
-        /* Userspace and kernelspace view of task state may differ.
-         * Model kernel state as an additional container
-         */
-        sched_trace_container_param(t->pid, t->comm);
-        sched_trace_server_param(-t->pid, t->pid,
-                                 get_exec_cost(t), get_rt_period(t));
-
         /* Setup job params */
         release_at(t, litmus_clock());
         if (running) {