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

2 files changed, 64 insertions, 0 deletions

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