Add preemption-and-migration overhead tracing supportwip-pm-ovd

Add per-task accounting (based on shared control page) of information
needed to trace preemption and migration overheads from userspace

4 files changed, 88 insertions, 1 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 5b94d1a8eea7..31630d729dbb 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -50,13 +50,26 @@ struct rt_task {
  * determining preemption/migration overheads).
  */
 struct control_page {
+        /* preemption and migration overheads measurement*/
+        /* execution start time */
+        lt_t preempt_end;
+        /* increased if last_rt != current */
+        unsigned long sched_count;
+        unsigned int cpu;
+        /* job number for this task */
+        unsigned long job_count;
+        /* last rt task before current one */
+        unsigned long last_rt_task;
+        /* execution stop time */
+        lt_t preempt_start;
+
         /* Is the task currently in a non-preemptive section? */
         int np_flag;
         /* Should the task call into the kernel when it leaves
          * its non-preemptive section? */
         int delayed_preemption;
 
-        /* to be extended */
+        /* what do you want to share today ? */
 };
 
 /* don't export internal data structures to user space (liblitmus) */
@@ -175,6 +188,10 @@ struct rt_param {
          */
         struct list_head list;
 
+        /* FIXME for overhead tracing it would be better
+         * having this page on top of rt_param and having rt_param
+         * closer to the top of task_struct
+         */
         /* Pointer to the page shared between userspace and kernel. */
         struct control_page * ctrl_page;
 };
diff --git a/kernel/sched.c b/kernel/sched.c
index 1701eaebb79c..69fb86c87915 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -489,6 +489,9 @@ struct rt_rq {
 struct litmus_rq {
         unsigned long nr_running;
         struct task_struct *prev;
+#ifdef CONFIG_PREEMPT_MIGRAT_OVD
+        unsigned int last_rt_task;
+#endif
 };
 
 #ifdef CONFIG_SMP
@@ -2766,8 +2769,11 @@ static void finish_task_switch(struct rq *rq, struct task_struct *prev)
          */
         prev_state = prev->state;
         finish_arch_switch(prev);
+
         litmus->finish_switch(prev);
         prev->rt_param.stack_in_use = NO_CPU;
+        trace_preempt_migrat_ovd(prev, current, rq);
+
         perf_event_task_sched_in(current, cpu_of(rq));
         finish_lock_switch(rq, prev);
 
diff --git a/litmus/Kconfig b/litmus/Kconfig
index 874794f64af1..77f65e512136 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -67,6 +67,16 @@ config SCHED_OVERHEAD_TRACE
           Export event stream for overhead tracing.
           Say Yes for overhead tracing.
 
+config PREEMPT_MIGRAT_OVD
+        bool "Preemption and migration overhead measurements"
+        default n
+        help
+          Include support for tracing preemption and migration overheads
+          in userspace. Unless you know the mess you are going into,
+          the safe choice is No. If you _really_ want to have some fun,
+          than say Yes and have a look in the liblitmus2010 library for
+          some program examples.
+
 config SCHED_DEBUG_TRACE
         bool "TRACE() debugging"
         default y
diff --git a/litmus/sched_litmus.c b/litmus/sched_litmus.c
index c1fc7748e590..be29cbe15fc5 100644
--- a/litmus/sched_litmus.c
+++ b/litmus/sched_litmus.c
@@ -316,3 +316,57 @@ const struct sched_class litmus_sched_class = {
         .prio_changed           = prio_changed_litmus,
         .switched_to            = switched_to_litmus,
 };
+
+#ifdef CONFIG_PREEMPT_MIGRAT_OVD
+/* trace_preempt_migrat_ovd() executes during finish_task_switch()
+ * before (possibly) giving control back to userspace
+ * Using shared rw (FIXME ro?) ctrl page we keep the userspace
+ * monitoring program updated on what happened during our execution
+ */
+static void trace_preempt_migrat_ovd(struct task_struct *prev,
+                                            struct task_struct *curr,
+                                            struct rq *rq)
+{
+        struct control_page *ctrl;
+
+        /* Update bookkeeping variables that are shared with userspace
+         * to conduct appropriate benchmarking (preempt, migration)
+         */
+        if (is_realtime(prev) && tsk_rt(prev)->ctrl_page) {
+                rq->litmus.last_rt_task =  prev->pid;
+                tsk_rt(prev)->ctrl_page->preempt_start = get_cycles();
+        }
+
+        if (is_realtime(current) && tsk_rt(current)->ctrl_page) {
+                ctrl = tsk_rt(current)->ctrl_page;
+                ctrl->preempt_end = get_cycles();
+
+                /* If the last RT task to be scheduled was not
+                 * this task, then the preemption "counts", and
+                 * we increment sched_count. Otherwise, we do
+                 * not. On a migration this might not get
+                 * incrememented, and we need to check for a cpu
+                 * change in that case (cpu is always updated).
+                 */
+                if (rq->litmus.last_rt_task != current->pid)
+                        ctrl->sched_count++;
+
+                /* "our" userspace will be eventually awoke sometimes
+                 * in the "near" future, we write on the shared page
+                 * some information for it
+                 */
+                ctrl->cpu =  rq->cpu;
+                ctrl->job_count = tsk_rt(current)->job_params.job_no;
+                ctrl->last_rt_task = rq->litmus.last_rt_task;
+                /* userspace has all the information to compute the length
+                 * of this preemption
+                 */
+        }
+}
+#else
+static inline void trace_preempt_migrat_ovd(struct task_struct *prev,
+                                            struct task_struct *curr,
+                                            struct rq *rq)
+{
+}
+#endif