PGM supportwip-mc2-new

4 files changed, 117 insertions, 2 deletions

diff --git a/include/litmus/pgm.h b/include/litmus/pgm.h
new file mode 100644
index 000000000000..5682a76b3acb
--- /dev/null
+++ b/include/litmus/pgm.h
@@ -0,0 +1,12 @@
+#ifndef _LITMUS_PGM_H_
+#define _LITMUS_PGM_H_
+
+#include <litmus/litmus.h>
+
+#define is_pgm_waiting(t) (tsk_rt(t)->ctrl_page && tsk_rt(t)->ctrl_page->pgm_waiting)
+#define is_pgm_sending(t) (tsk_rt(t)->ctrl_page && tsk_rt(t)->ctrl_page->pgm_sending)
+#define is_pgm_satisfied(t) (tsk_rt(t)->ctrl_page && tsk_rt(t)->ctrl_page->pgm_satisfied)
+
+int setup_pgm_release(struct task_struct* t);
+
+#endif
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index a3dde39753bd..fa0f5f4647bd 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -51,6 +51,14 @@ typedef enum {
         TASK_EARLY
 } release_policy_t;
 
+typedef enum {
+        PGM_NOT_A_NODE,
+        PGM_SRC,
+        PGM_SINK,
+        PGM_SRC_SINK,
+        PGM_INTERNAL
+} pgm_node_type_t;
+
 /* We use the common priority interpretation "lower index == higher priority",
  * which is commonly used in fixed-priority schedulability analysis papers.
  * So, a numerically lower priority value implies higher scheduling priority,
@@ -122,6 +130,8 @@ struct rt_task {
         task_class_t    cls;
         budget_policy_t  budget_policy;  /* ignored by pfair */
         release_policy_t release_policy;
+        pgm_node_type_t  pgm_type;
+        lt_t             pgm_expected_etoe;
 };
 
 union np_flag {
@@ -162,6 +172,11 @@ struct control_page {
         uint64_t irq_syscall_start; /* Snapshot of irq_count when the syscall
                                      * started. */
 
+        /* Flags from userspace signifying PGM wait states. */
+        volatile uint32_t       pgm_waiting;    /* waiting for tokens */
+        volatile uint32_t       pgm_sending;    /* sending tokens */
+        volatile uint32_t       pgm_satisfied;  /* done waiting/sending */
+
         /* to be extended */
 };
 
diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h
index 82bde8241298..d3f78a812ef3 100644
--- a/include/litmus/sched_trace.h
+++ b/include/litmus/sched_trace.h
@@ -80,6 +80,19 @@ struct st_sys_release_data {
         u64     release;
 };
 
+struct st_pgm_param_data {
+        u32 node_type;
+        u16 graph_pid;
+        u16 unused;
+        u64 expected_graph_etoe;
+};
+
+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 +107,9 @@ typedef enum {
         ST_BLOCK,
         ST_RESUME,
         ST_ACTION,
-        ST_SYS_RELEASE
+        ST_SYS_RELEASE,
+        ST_PGM_PARAM,
+        ST_PGM_RELEASE
 } st_event_record_type_t;
 
 struct st_event_record {
@@ -113,6 +128,8 @@ struct st_event_record {
                 DATA(resume);
                 DATA(action);
                 DATA(sys_release);
+                DATA(pgm_param);
+                DATA(pgm_release);
         } data;
 };
 
@@ -154,6 +171,10 @@ 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_param(unsigned long id,
+                                                struct task_struct* task);
+feather_callback void do_sched_trace_pgm_release(unsigned long id,
+                                                struct task_struct* task);
 
 #endif
 
@@ -179,6 +200,8 @@ 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_param(t)
+#define trace_litmus_pgm_release(t)
 
 #endif
 
@@ -252,6 +275,20 @@ feather_callback void do_sched_trace_sys_release(unsigned long id,
                 trace_litmus_sys_release(when);                         \
         } while (0)
 
+#define sched_trace_pgm_param(t)                                        \
+        do {                                                            \
+                SCHED_TRACE(SCHED_TRACE_BASE_ID + 11,                   \
+                                do_sched_trace_pgm_param, t);           \
+                trace_litmus_pgm_param(t);                                      \
+        } while (0)
+
+#define sched_trace_pgm_release(t)                                      \
+        do {                                                            \
+                SCHED_TRACE(SCHED_TRACE_BASE_ID + 12,                   \
+                                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..02b4b54f718c 100644
--- a/include/trace/events/litmus.h
+++ b/include/trace/events/litmus.h
@@ -39,7 +39,7 @@ TRACE_EVENT(litmus_task_param,
                 __entry->partition = get_partition(t);
         ),
 
-        TP_printk("period(%d, %Lu).\nwcet(%d, %Lu).\n",
+        TP_printk("period(%u, %Lu).\nwcet(%d, %Lu).\n",
                 __entry->pid, __entry->period,
                 __entry->pid, __entry->wcet)
 );
@@ -225,6 +225,57 @@ TRACE_EVENT(litmus_sys_release,
         TP_printk("SynRelease(%Lu) at %Lu\n", __entry->rel, __entry->when)
 );
 
+/* Tracing PGM node parameters */
+TRACE_EVENT(litmus_pgm_param,
+
+        TP_PROTO(struct task_struct *t),
+
+        TP_ARGS(t),
+
+        TP_STRUCT__entry(
+                __field( pid_t, pid )
+                __field( pgm_node_type_t, node_type )
+                __field( pid_t, graph_pid )
+        ),
+
+        TP_fast_assign(
+                __entry->pid            = t ? t->pid  : 0;
+                __entry->node_type      = t ? t->rt_param.task_params.pgm_type : PGM_NOT_A_NODE;
+                __entry->graph_pid      = t ? t->tgid : 0;
+        ),
+
+        TP_printk("pgm node (%u, node type = %d) in graph (%u)\n",
+                __entry->pid, __entry->node_type, __entry->graph_pid)
+);
+
+/*
+ * 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 */