Tracing for PGM release/deadline adjustment.

Patch adds tracing of job release/deadline adjustments
of PGM tasks. Tracing is separate from regular job tracing
so that we many observe the magnitude of adjustments/slippage.

4 files changed, 60 insertions, 2 deletions

diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h
index 82bde8241298..3d3b06ced797 100644
--- a/include/litmus/sched_trace.h
+++ b/include/litmus/sched_trace.h
@@ -80,6 +80,11 @@ struct st_sys_release_data {
         u64     release;
 };
 
+struct st_pgm_release_data {
+        u64     release;        /* PGM-adjusted release time */
+        u64     deadline;       /* PGM-adjusted deadline */
+};
+
 #define DATA(x) struct st_ ## x ## _data x;
 
 typedef enum {
@@ -94,7 +99,8 @@ typedef enum {
         ST_BLOCK,
         ST_RESUME,
         ST_ACTION,
-        ST_SYS_RELEASE
+        ST_SYS_RELEASE,
+        ST_PGM_RELEASE
 } st_event_record_type_t;
 
 struct st_event_record {
@@ -113,6 +119,7 @@ struct st_event_record {
                 DATA(resume);
                 DATA(action);
                 DATA(sys_release);
+                DATA(pgm_release);
         } data;
 };
 
@@ -154,6 +161,8 @@ feather_callback void do_sched_trace_action(unsigned long id,
                                             unsigned long action);
 feather_callback void do_sched_trace_sys_release(unsigned long id,
                                                  lt_t* start);
+feather_callback void do_sched_trace_pgm_release(unsigned long id,
+                                                struct task_struct* task);
 
 #endif
 
@@ -179,6 +188,7 @@ feather_callback void do_sched_trace_sys_release(unsigned long id,
 #define trace_litmus_task_block(t)
 #define trace_litmus_task_resume(t)
 #define trace_litmus_sys_release(start)
+#define trace_litmus_pgm_release(t)
 
 #endif
 
@@ -252,6 +262,13 @@ feather_callback void do_sched_trace_sys_release(unsigned long id,
                 trace_litmus_sys_release(when);                         \
         } while (0)
 
+#define sched_trace_pgm_release(t)                                      \
+        do {                                                            \
+                SCHED_TRACE(SCHED_TRACE_BASE_ID + 11,                   \
+                                do_sched_trace_pgm_release, t); \
+                trace_litmus_pgm_release(t);                            \
+        } while (0)
+
 #define sched_trace_quantum_boundary() /* NOT IMPLEMENTED */
 
 #endif /* __KERNEL__ */
diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h
index 0fffcee02be0..0b4eac386dfe 100644
--- a/include/trace/events/litmus.h
+++ b/include/trace/events/litmus.h
@@ -225,6 +225,34 @@ TRACE_EVENT(litmus_sys_release,
         TP_printk("SynRelease(%Lu) at %Lu\n", __entry->rel, __entry->when)
 );
 
+/*
+ * Tracing PGM-adjusted job release
+ */
+TRACE_EVENT(litmus_pgm_release,
+
+        TP_PROTO(struct task_struct *t),
+
+        TP_ARGS(t),
+
+        TP_STRUCT__entry(
+                __field( pid_t,         pid     )
+                __field( unsigned int,  job     )
+                __field( lt_t,          release )
+                __field( lt_t,          deadline        )
+        ),
+
+        TP_fast_assign(
+                __entry->pid    = t ? t->pid : 0;
+                __entry->job    = t ? t->rt_param.job_params.job_no : 0;
+                __entry->release        = get_release(t);
+                __entry->deadline       = get_deadline(t);
+        ),
+
+        TP_printk("release(job(%u, %u)): %Lu\ndeadline(job(%u, %u)): %Lu\n",
+                        __entry->pid, __entry->job, __entry->release,
+                        __entry->pid, __entry->job, __entry->deadline)
+);
+
 #endif /* _SCHED_TASK_TRACEPOINT_H */
 
 /* Must stay outside the protection */
diff --git a/litmus/pgm.c b/litmus/pgm.c
index f8b857de8118..2bfa8d0843c1 100644
--- a/litmus/pgm.c
+++ b/litmus/pgm.c
@@ -4,6 +4,7 @@
 #include <linux/sched.h>
 #include <litmus/litmus.h>
 #include <litmus/pgm.h>
+#include <litmus/sched_trace.h>
 
 /* Only readjust release/deadline if difference is over a given threshold.
    It's a weak method for accounting overheads. Ideally, we'd know the last
@@ -51,4 +52,6 @@ void setup_pgm_release(struct task_struct* t)
                         "cur time = %llu, release time = %llu\n",
                         now, tsk_rt(t)->job_params.release);
         }
+
+        sched_trace_pgm_release(t);
 }
diff --git a/litmus/sched_task_trace.c b/litmus/sched_task_trace.c
index 933e7e4c7094..422314f29a60 100644
--- a/litmus/sched_task_trace.c
+++ b/litmus/sched_task_trace.c
@@ -231,10 +231,20 @@ feather_callback void do_sched_trace_action(unsigned long id,
 {
         struct task_struct *t = (struct task_struct*) _task;
         struct st_event_record* rec = get_record(ST_ACTION, t);
-
         if (rec) {
                 rec->data.action.when   = now();
                 rec->data.action.action = action;
                 put_record(rec);
         }
 }
+
+feather_callback void do_sched_trace_pgm_release(unsigned long id, unsigned long _task)
+{
+        struct task_struct *t = (struct task_struct*) _task;
+        struct st_event_record* rec = get_record(ST_PGM_RELEASE, t);
+        if (rec) {
+                rec->data.release.release  = get_release(t);
+                rec->data.release.deadline = get_deadline(t);
+                put_record(rec);
+        }
+}