Fixed migration tracing. Added inject of ST_ACTION

3 files changed, 64 insertions, 50 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index c4cba8551c47..de20eff7cf71 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -59,14 +59,20 @@ typedef enum {
         ST_INJECT_COMPLETION,                   /* supported */
         ST_INJECT_BLOCK,
         ST_INJECT_RESUME,
-        ST_INJECT_ACTION,
+        ST_INJECT_ACTION,                               /* supported */
         ST_INJECT_SYS_RELEASE,                  /* supported */
 } sched_trace_injection_events_t;
 
 struct st_inject_args {
-        lt_t release;
-        lt_t deadline;
-        unsigned int job_no;
+        union
+        {
+                struct{
+                        lt_t release;
+                        lt_t deadline;
+                        unsigned int job_no;
+                };
+                unsigned int action;
+        };
 };
 
 /* We use the common priority interpretation "lower index == higher priority",
diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h
index 0d22c275dd72..0785db39b2fc 100644
--- a/include/litmus/sched_trace.h
+++ b/include/litmus/sched_trace.h
@@ -61,7 +61,8 @@ struct st_completion_data {	/* A job completed. */
 
 struct st_block_data {          /* A task blocks. */
         u64     when;
-        u64     __unused;
+        u8      for_io;
+        u8      __unused[7];
 } __attribute__((packed));
 
 struct st_resume_data {         /* A task resumes. */
@@ -71,8 +72,8 @@ struct st_resume_data {		/* A task resumes. */
 
 struct st_action_data {
         u64     when;
-        u8      action;
-        u8      __unused[7];
+        u32     action;
+        u8      __unused[4];
 } __attribute__((packed));
 
 struct st_sys_release_data {
@@ -138,20 +139,24 @@ struct st_nv_interrupt_end_data {
         u32 serialNumber;
 } __attribute__((packed));
 
-struct st_prediction_err_data {
-        u64 distance;
-        u64 rel_err;
-} __attribute__((packed));
-
 struct st_migration_data {
         u64 observed;
         u64 estimated;
 } __attribute__((packed));
 
+
+/* passed as an argument to tracing for st_migration_data */
 struct migration_info {
         u64 observed;
         u64 estimated;
         u8 distance;
+};
+
+struct st_lock_data{
+        u64 when;
+        u32 lock_id;
+        u8      acquired;
+        u8      __unused[3];
 } __attribute__((packed));
 
 #define DATA(x) struct st_ ## x ## _data x;
@@ -179,8 +184,8 @@ typedef enum {
         ST_NV_INTERRUPT_BEGIN,
         ST_NV_INTERRUPT_END,
 
-        ST_PREDICTION_ERR,
         ST_MIGRATION,
+        ST_LOCK
 } st_event_record_type_t;
 
 struct st_event_record {
@@ -209,8 +214,8 @@ struct st_event_record {
                 DATA(nv_interrupt_begin);
                 DATA(nv_interrupt_end);
 
-                DATA(prediction_err);
                 DATA(migration);
+                DATA(lock);
         } data;
 } __attribute__((packed));
 
@@ -284,19 +289,14 @@ feather_callback void do_sched_trace_nv_interrupt_begin(unsigned long id,
 feather_callback void do_sched_trace_nv_interrupt_end(unsigned long id,
                                                                                                 unsigned long unused);
 
-feather_callback void do_sched_trace_prediction_err(unsigned long id,
-                                                                                                          struct task_struct* task,
-                                                                                                          gpu_migration_dist_t* distance,
-                                                                                                          fp_t* rel_err);
-
-
-
-
-
 feather_callback void do_sched_trace_migration(unsigned long id,
                                                                                           struct task_struct* task,
                                                                                           struct migration_info* mig_info);
 
+feather_callback void do_sched_trace_lock(unsigned long id,
+                                                                                  struct task_struct* task,
+                                                                                  unsigned long lock_id,
+                                                                                  unsigned long acquired);
 
 /* returns true if we're tracing an interrupt on current CPU */
 /* int is_interrupt_tracing_active(void); */
@@ -428,11 +428,14 @@ feather_callback void do_sched_trace_migration(unsigned long id,
 #define sched_trace_nv_interrupt_end(d) \
         SCHED_TRACE(SCHED_TRACE_BASE_ID + 19, do_sched_trace_nv_interrupt_end, d)
 
-#define sched_trace_prediction_err(t, dist, rel_err) \
-        SCHED_TRACE3(SCHED_TRACE_BASE_ID + 20, do_sched_trace_prediction_err, t, dist, rel_err)
-
 #define sched_trace_migration(t, mig_info) \
-        SCHED_TRACE2(SCHED_TRACE_BASE_ID + 21, do_sched_trace_migration, t, mig_info)
+        SCHED_TRACE2(SCHED_TRACE_BASE_ID + 20, do_sched_trace_migration, t, mig_info)
+
+
+#define sched_trace_lock(t, lock_id, acquired) \
+        SCHED_TRACE3(SCHED_TRACE_BASE_ID + 21, do_sched_trace_lock, t, lock_id, acquired)
+
+
 
 #define sched_trace_quantum_boundary() /* NOT IMPLEMENTED */
 
diff --git a/litmus/sched_task_trace.c b/litmus/sched_task_trace.c
index d1df0127cfa4..e863eaf41b96 100644
--- a/litmus/sched_task_trace.c
+++ b/litmus/sched_task_trace.c
@@ -200,8 +200,21 @@ feather_callback void do_sched_trace_task_block(unsigned long id,
 {
         struct task_struct *t = (struct task_struct*) _task;
         struct st_event_record* rec = get_record(ST_BLOCK, t);
+
         if (rec) {
-                rec->data.block.when      = now();
+                rec->data.block.when = now();
+
+                // hiding is turned on by locking protocols, so if there isn't any
+                // hiding, then we're blocking for some other reason.  assume it's I/O.
+                rec->data.block.for_io = 0
+#ifdef CONFIG_REALTIME_AUX_TASKS
+                || (tsk_rt(t)->has_aux_tasks && !tsk_rt(t)->hide_from_aux_tasks)
+#endif
+#ifdef CONFIG_LITMUS_NVIDIA
+                || (tsk_rt(t)->held_gpus && !tsk_rt(t)->hide_from_gpu)
+#endif
+                ;
+
                 put_record(rec);
         }
 }
@@ -243,28 +256,6 @@ feather_callback void do_sched_trace_action(unsigned long id,
         }
 }
 
-
-
-
-feather_callback void do_sched_trace_prediction_err(unsigned long id,
-                                                                                                        unsigned long _task,
-                                                                                                        unsigned long _distance,
-                                                                                                        unsigned long _rel_err)
-{
-        struct task_struct *t = (struct task_struct*) _task;
-        struct st_event_record *rec = get_record(ST_PREDICTION_ERR, t);
-
-        if (rec) {
-                gpu_migration_dist_t* distance = (gpu_migration_dist_t*) _distance;
-                fp_t* rel_err = (fp_t*) _rel_err;
-
-                rec->data.prediction_err.distance = *distance;
-                rec->data.prediction_err.rel_err = rel_err->val;
-                put_record(rec);
-        }
-}
-
-
 feather_callback void do_sched_trace_migration(unsigned long id,
                                                                                                         unsigned long _task,
                                                                                                         unsigned long _mig_info)
@@ -285,7 +276,21 @@ feather_callback void do_sched_trace_migration(unsigned long id,
 
 
 
+feather_callback void do_sched_trace_lock(unsigned long id,
+                                                 unsigned long _task,
+                                                 unsigned long _lock_id,
+                                                 unsigned long _acquired)
+{
+        struct task_struct *t = (struct task_struct*) _task;
+        struct st_event_record *rec = get_record(ST_LOCK, t);
 
+        if (rec) {
+                rec->data.lock.when = now();
+                rec->data.lock.lock_id = _lock_id;
+                rec->data.lock.acquired = _acquired;
+                put_record(rec);
+        }
+}