Feather-Trace: add support for locking-related syscall overheads

Support recording timestamps that allow tracing the entry and exit
costs of locking-related system calls.

4 files changed, 42 insertions, 0 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index 807b7888695a..f7893ef18162 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -259,4 +259,20 @@ static inline quanta_t time2quanta(lt_t time, enum round round)
 /* By how much is cpu staggered behind CPU 0? */
 u64 cpu_stagger_offset(int cpu);
 
+static inline struct control_page* get_control_page(struct task_struct *t)
+{
+        return tsk_rt(t)->ctrl_page;
+}
+
+static inline int has_control_page(struct task_struct* t)
+{
+        return tsk_rt(t)->ctrl_page != NULL;
+}
+
+
+#define TS_SYSCALL_IN_START                                             \
+        if (has_control_page(current)) {                                \
+                __TS_SYSCALL_IN_START(&get_control_page(current)->ts_syscall_start); \
+        }
+
 #endif
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index fac939dbd33a..6456ed04fddb 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -89,8 +89,14 @@ union np_flag {
  * determining preemption/migration overheads).
  */
 struct control_page {
+        /* This flag is used by userspace to communicate non-preempive
+         * sections. */
         volatile union np_flag sched;
 
+        /* Locking overhead tracing: userspace records here the time stamp
+         * prior to starting the system call. */
+        uint64_t ts_syscall_start; /* Feather-Trace cycles */
+
         /* to be extended */
 };
 
diff --git a/litmus/locking.c b/litmus/locking.c
index df7d0a939c08..43d9aece2e74 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -1,3 +1,5 @@
+#include <linux/sched.h>
+#include <litmus/litmus.h>
 #include <litmus/fdso.h>
 
 #ifdef CONFIG_LITMUS_LOCKING
@@ -72,6 +74,10 @@ asmlinkage long sys_litmus_lock(int lock_od)
         struct od_table_entry* entry;
         struct litmus_lock* l;
 
+        TS_SYSCALL_IN_START;
+
+        TS_SYSCALL_IN_END;
+
         TS_LOCK_START;
 
         entry = get_entry_for_od(lock_od);
@@ -85,6 +91,8 @@ asmlinkage long sys_litmus_lock(int lock_od)
          * this into account when computing overheads. */
         TS_LOCK_END;
 
+        TS_SYSCALL_OUT_START;
+
         return err;
 }
 
@@ -94,6 +102,10 @@ asmlinkage long sys_litmus_unlock(int lock_od)
         struct od_table_entry* entry;
         struct litmus_lock* l;
 
+        TS_SYSCALL_IN_START;
+
+        TS_SYSCALL_IN_END;
+
         TS_UNLOCK_START;
 
         entry = get_entry_for_od(lock_od);
@@ -107,6 +119,8 @@ asmlinkage long sys_litmus_unlock(int lock_od)
          * account when computing overheads. */
         TS_UNLOCK_END;
 
+        TS_SYSCALL_OUT_START;
+
         return err;
 }
 
@@ -156,6 +170,7 @@ out:
         return passed;
 }
 
+
 #else
 
 struct fdso_ops generic_lock_ops = {};
diff --git a/litmus/sched_litmus.c b/litmus/sched_litmus.c
index 6553948407de..6b32cf09abbd 100644
--- a/litmus/sched_litmus.c
+++ b/litmus/sched_litmus.c
@@ -194,6 +194,9 @@ static void dequeue_task_litmus(struct rq *rq, struct task_struct *p,
 
 static void yield_task_litmus(struct rq *rq)
 {
+        TS_SYSCALL_IN_START;
+        TS_SYSCALL_IN_END;
+
         BUG_ON(rq->curr != current);
         /* sched_yield() is called to trigger delayed preemptions.
          * Thus, mark the current task as needing to be rescheduled.
@@ -202,6 +205,8 @@ static void yield_task_litmus(struct rq *rq)
          */
         clear_exit_np(current);
         litmus_reschedule_local();
+
+        TS_SYSCALL_OUT_START;
 }
 
 /* Plugins are responsible for this.