rt-graph: real-time task plots divorced from regular task plots

7 files changed, 256 insertions, 242 deletions

diff --git a/rt-graph.c b/rt-graph.c
index 3e9f248..d6b1847 100644
--- a/rt-graph.c
+++ b/rt-graph.c
@@ -1,7 +1,7 @@
-#include "rt-graph.h"
+#include "trace-graph.h"
 #include "trace-hash.h"
 
-#define DEBUG_LEVEL     0
+#define DEBUG_LEVEL     4
 #if DEBUG_LEVEL > 0
 #define dprintf(l, x...)                        \
         do {                                    \
@@ -17,6 +17,9 @@ static guint get_event_hash_key(gint eid)
         return trace_hash(eid) % TS_HASH_SIZE;
 }
 
+/*
+ * Returns cached field for @eid at @key.
+ */
 struct format_field* find_ts_hash(struct ts_list **events,
                                   gint key, gint eid)
 {
@@ -29,10 +32,11 @@ struct format_field* find_ts_hash(struct ts_list **events,
 }
 
 /*
- * Return format field for @eid, caching its location if this is the first try
+ * Return field for @eid at @key, caching if necessary.
  */
-static struct format_field* add_ts_hash(struct ts_list **events, gint eid, gint key,
-                                        struct pevent *pevent, struct record *record)
+static struct format_field*
+add_ts_hash(struct ts_list **events, gint eid, gint key,
+            struct pevent *pevent, struct record *record)
 {
         struct ts_list *list;
         struct format_field *field;
@@ -59,16 +63,12 @@ static struct format_field* add_ts_hash(struct ts_list **events, gint eid, gint
  */
 int rt_graph_check_any(struct rt_graph_info *rtinfo,
                        struct pevent *pevent, struct record *record,
-                       gint *epid, unsigned long long *ts)
+                       gint *epid, gint *out_eid, unsigned long long *ts)
 {
         guint key, eid;
         struct format_field *field;
 
         eid = pevent_data_type(pevent, record);
-
-        if (eid == rtinfo->switch_away_id)
-                return 0;
-
         key = get_event_hash_key(eid);
         field = find_ts_hash(rtinfo->events, key, eid);
 
@@ -80,6 +80,7 @@ int rt_graph_check_any(struct rt_graph_info *rtinfo,
 
         dprintf(3, "Read (%d) record for task %d at %llu\n",
                 eid, *epid, *ts);
+        *out_eid = eid;
         return 1;
 }
 
@@ -222,7 +223,7 @@ int rt_graph_check_switch_away(struct rt_graph_info *rtinfo,
 
 /**
  * rt_graph_check_task_release - check for litmus_task_release record
- * Return 1 and @pid, @job, and @deadline if the record matches
+ * Return 1 and @pid, @job, @release, and @deadline if the record matches
  */
 int rt_graph_check_task_release(struct rt_graph_info *rtinfo,
                                 struct pevent *pevent, struct record *record,
@@ -271,7 +272,7 @@ int rt_graph_check_task_release(struct rt_graph_info *rtinfo,
 
 /**
  * rt_graph_check_task_completion - check for litmus_task_completion record
- * Return 1 and @pid, @job if the record matches
+ * Return 1 and @pid, @job, and @ts if the record matches
  */
 int rt_graph_check_task_completion(struct rt_graph_info *rtinfo,
                                    struct pevent *pevent, struct record *record,
@@ -314,7 +315,7 @@ int rt_graph_check_task_completion(struct rt_graph_info *rtinfo,
 
 /**
  * rt_graph_check_task_block - check for litmus_task_block record
- * Return 1 and @pid if the record matches
+ * Return 1, @pid, and @ts if the record matches
  */
 int rt_graph_check_task_block(struct rt_graph_info *rtinfo,
                               struct pevent *pevent, struct record *record,
@@ -431,3 +432,119 @@ void init_rt_event_cache(struct rt_graph_info *rtinfo)
         rtinfo->resume_pid_field = NULL;
         rtinfo->resume_ts_field = NULL;
 }
+
+/**
+ * get_rts - extract real-time timestamp from a record
+ *
+ * This will only have to extract the timestamp once; after the time
+ * is extracted it will be cached in the record itself.
+ */
+unsigned long long
+get_rts(struct graph_info *ginfo, struct record *record)
+{
+        gint epid, eid;
+        unsigned long long ts;
+        if (!record->cached_rts) {
+                rt_graph_check_any(&ginfo->rtinfo, ginfo->pevent, record,
+                                   &epid, &eid, &ts);
+                record->cached_rts = ts;
+        } else
+                ts = record->cached_rts;
+        return ts;
+}
+
+/**
+ * next_rts - find a real-time timestamp AROUND an FTRACE time
+ * @ginfo: Current state of the graph
+ * @cpu: CPU to search
+ * @ft_target: FTRACE time to seek towards
+ *
+ * Returns the RT time of a record CLOSELY BEFORE @ft_time.
+ */
+unsigned long long
+next_rts(struct graph_info *ginfo, int cpu, unsigned long long ft_target)
+{
+        struct record *record;
+        unsigned long long ts = 0ULL;
+        tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, ft_target);
+        record = tracecmd_read_data(ginfo->handle, cpu);
+        if (record) {
+                ts = get_rts(ginfo, record);
+                free_record(record);
+                return ts;
+        } else
+                return 0;
+}
+
+/**
+ * set_cpu_to_rts - seek CPU to a time closely preceding a real-time timestamp
+ * @ginfo: Current state o the graph
+ * @cpu: The CPU to seek
+ * @rt_target: RT time to seek towards
+ *
+ * This seeks to a real-time timestamp, not the default ftrace timestamps.
+ * The @cpu seek location will be placed before the given time, but will
+ * not necessarily be placed _right_ before the time.
+ */
+void
+set_cpu_to_rts(struct graph_info *ginfo, unsigned long long rt_target, int cpu)
+{
+        struct record *record;
+        unsigned long long last_rts, rts, seek_time, last_seek;
+        long long diff;
+
+        rts = next_rts(ginfo, cpu, rt_target);
+        diff = rt_target - rts;
+
+        /* "Guess" a new target based on difference */
+        seek_time = rt_target + diff;
+        rts = next_rts(ginfo, cpu, seek_time);
+        diff = rt_target - rts;
+
+        /* Zero in in 1.5x the difference increments */
+        if (rts && diff > 0) {
+                /*   rts      rt_target
+                 *   seek        ?
+                 * ---|---->>----|---
+                 */
+                do {
+                        last_seek = seek_time;
+                        last_rts = rts;
+                        seek_time = seek_time + 1.5 * (rt_target - rts);
+                        rts = next_rts(ginfo, cpu, seek_time);
+                } while (rts < rt_target && last_rts != rts);
+                tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, last_seek);
+                seek_time = last_seek;
+        } else if (rts && diff < 0) {
+                /* rt_target    rts
+                 *    ?         seek
+                 * ---|----<<----|---
+                 */
+                do {
+                        seek_time = seek_time - 1.5 * (rts - rt_target);
+                        rts = next_rts(ginfo, cpu, seek_time);
+                } while (rts > rt_target);
+        }
+
+        /* Get to first record at or after time */
+        while ((record = tracecmd_read_data(ginfo->handle, cpu))) {
+                if (get_rts(ginfo, record) >= rt_target)
+                        break;
+                free_record(record);
+        }
+        if (record) {
+                tracecmd_set_cursor(ginfo->handle, cpu, record->offset);
+                free_record(record);
+        } else
+                tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, seek_time);
+}
+
+/**
+ * set_cpus_to_time - seek all cpus to real-time @rt_target
+ */
+void set_cpus_to_rts(struct graph_info *ginfo, unsigned long long rt_target)
+{
+        int cpu;
+        for (cpu = 0; cpu < ginfo->cpus; cpu++)
+                set_cpu_to_rts(ginfo, rt_target, cpu);
+}
diff --git a/rt-graph.h b/rt-graph.h
index eeae270..1a6ef0c 100644
--- a/rt-graph.h
+++ b/rt-graph.h
@@ -65,7 +65,7 @@ struct ts_list {
 /* Event parsers */
 int rt_graph_check_any(struct rt_graph_info *rtinfo,
                        struct pevent *pevent, struct record *record,
-                       gint *pid, unsigned long long *ts);
+                       gint *pid, gint *eid, unsigned long long *ts);
 int rt_graph_check_task_param(struct rt_graph_info *rtinfo, struct pevent *pevent,
                               struct record *record, gint *pid,
                               unsigned long long *wcet,
@@ -91,4 +91,14 @@ int rt_graph_check_task_resume(struct rt_graph_info *rtinfo, struct pevent *peve
                                unsigned long long *when);
 void init_rt_event_cache(struct rt_graph_info *rtinfo);
 
+/* Methods for dealing with RT timestamps */
+unsigned long long get_rts(struct graph_info *ginfo,
+                           struct record *record);
+unsigned long long next_rts(struct graph_info *ginfo, int cpu,
+                            unsigned long long ft_target);
+void set_cpu_to_rts(struct graph_info *ginfo,
+                    unsigned long long rt_target, int cpu);
+void set_cpus_to_rts(struct graph_info *ginfo,
+                     unsigned long long rt_target);
+
 #endif
diff --git a/rt-plot-task.c b/rt-plot-task.c
index 31f4c7e..f28b7b1 100644
--- a/rt-plot-task.c
+++ b/rt-plot-task.c
@@ -1,4 +1,5 @@
 #include "trace-graph.h"
+#include "trace-filter.h"
 
 #define LLABEL 30
 
@@ -13,105 +14,11 @@
 #define dprintf(l, x...)        do { if (0) printf(x); } while (0)
 #endif
 
-/*
- * Extract timestamp from a record, attempting to use cache if possible
- */
-static unsigned long long
-get_rts(struct graph_info *ginfo, struct record *record)
-{
-        gint epid;
-        unsigned long long ts;
-        if (!record->cached_rts) {
-                rt_graph_check_any(&ginfo->rtinfo, ginfo->pevent, record,
-                                   &epid, &ts);
-                record->cached_rts = ts;
-        } else
-                ts = record->cached_rts;
-        return ts;
-}
-
-/*
- * Get the real-time timestamp of the next record at time
- */
-static unsigned long long
-next_rts(struct graph_info *ginfo, int cpu, unsigned long long time)
-{
-        struct record *record;
-        unsigned long long ts;
-        tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, time);
-        record = tracecmd_read_data(ginfo->handle, cpu);
-        if (record) {
-                ts = get_rts(ginfo, record);
-                free_record(record);
-                return ts;
-        } else
-                return 0;
-}
-
-static void set_cpu_to_time(int cpu, struct graph_info *ginfo, unsigned long long time)
-{
-        struct record *record;
-        unsigned long long last_rts, rts, seek_time, last_seek;
-        long long diff;
-
-        rts = next_rts(ginfo, cpu, time);
-        diff = time - rts;
-
-        /* "Guess" a new target based on difference */
-        seek_time = time + diff;
-        rts = next_rts(ginfo, cpu, seek_time);
-        diff = time - rts;
-
-        /* Zero in in 1.5x the difference increments */
-        if (rts && diff > 0) {
-                /*   rts       time
-                 *   seek        ?
-                 * ---|---->>----|---
-                 */
-                do {
-                        last_seek = seek_time;
-                        last_rts = rts;
-                        seek_time = seek_time + 1.5 * (time - rts);
-                        rts = next_rts(ginfo, cpu, seek_time);
-                } while (rts < time && last_rts != rts);
-                tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, last_seek);
-                seek_time = last_seek;
-        } else if (rts && diff < 0) {
-                /*   time      rts
-                 *    ?        seek
-                 * ---|----<<----|---
-                 */
-                do {
-                        seek_time = seek_time - 1.5 * (rts - time);
-                        rts = next_rts(ginfo, cpu, seek_time);
-                } while (rts > time);
-        }
-
-        /* Get to first record at or after time */
-        while ((record = tracecmd_read_data(ginfo->handle, cpu))) {
-                if (get_rts(ginfo, record) >= time)
-                        break;
-                free_record(record);
-        }
-        if (record) {
-                tracecmd_set_cursor(ginfo->handle, cpu, record->offset);
-                free_record(record);
-        } else
-                tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, seek_time);
-}
-
-void set_cpus_to_time(struct graph_info *ginfo, unsigned long long time)
-{
-        int cpu;
-        for (cpu = 0; cpu < ginfo->cpus; cpu++)
-                set_cpu_to_time(cpu, ginfo, time);
-}
-
 static gboolean record_matches_pid(struct graph_info *ginfo,
                                    struct record *record,
                                    int match_pid)
 {
-        gint dint, pid = 0, match = 0;
+        gint dint, pid = 0, match;
         unsigned long long dull;
         struct rt_graph_info *rtg_info = &ginfo->rtinfo;
 
@@ -125,29 +32,46 @@ static gboolean record_matches_pid(struct graph_info *ginfo,
                 rt_graph_check_task_completion(MARGS, &dint, &dull)     ||
                 rt_graph_check_task_block(MARGS, &dull)                 ||
                 rt_graph_check_task_resume(MARGS, &dull)                ||
-                rt_graph_check_any(MARGS, &dull);
+                rt_graph_check_any(MARGS, &dint, &dull);
 #undef MARGS
-        return match && pid == match_pid;
+        return pid == match_pid;
 }
 
-struct record*
-find_record(struct graph_info *ginfo, gint pid, guint64 time)
+static struct record*
+__find_record(struct graph_info *ginfo, gint pid, guint64 time, int display)
 {
-        int next_cpu, match;
+        int next_cpu, match, eid, is_sa = 0;
         struct record *record = NULL;
+        struct rt_graph_info *rtg_info = &ginfo->rtinfo;
 
-        set_cpus_to_time(ginfo, time);
+        set_cpus_to_rts(ginfo, time);
         do {
                 free_record(record);
                 record = tracecmd_read_next_data(ginfo->handle, &next_cpu);
                 if (!record)
                         return NULL;
                 match = record_matches_pid(ginfo, record, pid);
-        } while (!(get_rts(ginfo, record) > time && match));
+                if (display) {
+                        eid = pevent_data_type(ginfo->pevent, record);
+                        is_sa = (eid == rtg_info->switch_away_id);
+                }
+        } while (!(get_rts(ginfo, record) > time && match && !is_sa));
 
         return record;
 }
 
+static inline struct record*
+find_record(struct graph_info *ginfo, gint pid, guint64 time)
+{
+        return __find_record(ginfo, pid, time, 0);
+}
+
+static inline struct record*
+find_display_record(struct graph_info *ginfo, gint pid, guint64 time)
+{
+        return __find_record(ginfo, pid, time, 1);
+}
+
 /*
  * Update current job in @rtt_info, ensuring monotonic increase
  */
@@ -155,12 +79,12 @@ static int update_job(struct rt_task_info *rtt_info, int job)
 {
         if (job < rtt_info->last_job) {
                 printf("Inconsistent job state for %d:%d -> %d\n",
-                    rtt_info->base.pid, rtt_info->last_job, job);
+                    rtt_info->pid, rtt_info->last_job, job);
                 return 0;
         } else if (job > rtt_info->last_job) {
                 rtt_info->last_job = job;
                 snprintf(rtt_info->label, LLABEL, "%d:%d",
-                         rtt_info->base.pid, rtt_info->last_job);
+                         rtt_info->pid, rtt_info->last_job);
         }
         return 1;
 }
@@ -177,7 +101,7 @@ static int try_param(struct graph_info *ginfo, struct rt_task_info *rtt_info,
 
         match = rt_graph_check_task_param(&ginfo->rtinfo, ginfo->pevent,
                                           record, &pid, &wcet, &period);
-        if (match && pid == rtt_info->base.pid) {
+        if (match && pid == rtt_info->pid) {
                 update_job(rtt_info, 0);
                 rtt_info->wcet = wcet;
                 rtt_info->period = period;
@@ -199,7 +123,7 @@ static int try_release(struct graph_info *ginfo, struct rt_task_info *rtt_info,
         match = rt_graph_check_task_release(&ginfo->rtinfo, ginfo->pevent,
                                             record, &pid, &job,
                                             &release, &deadline);
-        if (match && pid == rtt_info->base.pid) {
+        if (match && pid == rtt_info->pid) {
                 update_job(rtt_info, job);
                 info->release = TRUE;
                 info->rtime = release;
@@ -226,7 +150,7 @@ static int try_completion(struct graph_info *ginfo,
 
         match = rt_graph_check_task_completion(&ginfo->rtinfo, ginfo->pevent,
                                                record, &pid, &job, &ts);
-        if (match && pid == rtt_info->base.pid) {
+        if (match && pid == rtt_info->pid) {
                 update_job(rtt_info, job);
                 info->completion = TRUE;
                 info->ctime = ts;
@@ -244,7 +168,7 @@ static int try_block(struct graph_info *ginfo, struct rt_task_info *rtt_info,
 
         match = rt_graph_check_task_block(&ginfo->rtinfo, ginfo->pevent,
                                           record, &pid, &ts);
-        if (match && pid == rtt_info->base.pid) {
+        if (match && pid == rtt_info->pid) {
                 rtt_info->block_time = ts;
                 ret = 1;
         }
@@ -259,13 +183,13 @@ static int try_resume(struct graph_info *ginfo, struct rt_task_info *rtt_info,
 
         match = rt_graph_check_task_resume(&ginfo->rtinfo, ginfo->pevent,
                                            record, &pid, &ts);
-        if (match && pid == rtt_info->base.pid) {
-                info->box = TRUE;
-                info->bcolor = 0x0;
-                info->bfill = TRUE;
-                info->bthin = TRUE;
-                info->bstart = rtt_info->block_time;
-                info->bend = ts;
+        if (match && pid == rtt_info->pid) {
+                /* info->box = TRUE; */
+                /* info->bcolor = 0x0; */
+                /* info->bfill = TRUE; */
+                /* info->bthin = TRUE; */
+                /* info->bstart = rtt_info->block_time; */
+                /* info->bend = ts; */
 
                 rtt_info->block_time = 0ULL;
 
@@ -283,12 +207,12 @@ try_switch_away(struct graph_info *ginfo, struct rt_task_info *rtt_info,
 
         match = rt_graph_check_switch_away(&ginfo->rtinfo, ginfo->pevent,
                                            record, &pid, &job, &ts);
-        if (match && pid == rtt_info->base.pid) {
+        if (match && pid == rtt_info->pid) {
                 update_job(rtt_info, job);
 
                 if (rtt_info->run_time && rtt_info->run_time < ts) {
                         dprintf(3, "Box for %d:%d, %llu to %llu on CPU %d\n",
-                                rtt_info->base.pid, rtt_info->last_job,
+                                rtt_info->pid, rtt_info->last_job,
                                 rtt_info->run_time, ts, rtt_info->last_cpu);
                         info->box = TRUE;
                         info->bcolor = hash_cpu(rtt_info->last_cpu);
@@ -298,6 +222,7 @@ try_switch_away(struct graph_info *ginfo, struct rt_task_info *rtt_info,
                         info->blabel = rtt_info->label;
                 }
 
+                dprintf(3, "Switch away at %llu\n", ts);
                 rtt_info->run_time = 0ULL;
                 rtt_info->last_cpu = -1;
 
@@ -314,14 +239,14 @@ static int try_switch_to(struct graph_info *ginfo, struct rt_task_info *rtt_info
 
         match = rt_graph_check_switch_to(&ginfo->rtinfo, ginfo->pevent,
                                          record, &pid, &job, &ts);
-        if (match && pid == rtt_info->base.pid) {
+        if (match && pid == rtt_info->pid) {
                 update_job(rtt_info, job);
 
                 rtt_info->run_time = ts;
                 rtt_info->last_cpu = record->cpu;
 
                 dprintf(3, "Switching to %d:%d at %llu on CPU %d\n",
-                        rtt_info->base.pid, rtt_info->last_job,
+                        rtt_info->pid, rtt_info->last_job,
                         ts, rtt_info->last_cpu);
 
                 ret = 1;
@@ -332,14 +257,17 @@ static int try_switch_to(struct graph_info *ginfo, struct rt_task_info *rtt_info
 static int try_other(struct graph_info *ginfo, struct rt_task_info *rtt_info,
                    struct record *record, struct plot_info *info)
 {
-        int pid, epid, ret = 0;
+        int pid, eid, epid, my_pid, my_cpu, not_sa, ret = 0;
         unsigned long long ts;
-        struct task_plot_info *task_info = &rtt_info->base;
 
-        pid = task_info->pid;
-        rt_graph_check_any(&ginfo->rtinfo, ginfo->pevent, record, &epid, &ts);
+        pid = rtt_info->pid;
+        rt_graph_check_any(&ginfo->rtinfo, ginfo->pevent, record,
+                           &epid, &eid, &ts);
 
-        if (pid == epid || record->cpu == rtt_info->last_cpu) {
+        my_pid = (pid == epid);
+        my_cpu = (rtt_info->run_time && record->cpu == rtt_info->last_cpu);
+        not_sa = (eid != ginfo->rtinfo.switch_away_id);
+        if (not_sa && (my_pid || my_cpu)) {
                 info->line = TRUE;
                 info->lcolor = hash_pid(record->cpu);
                 info->ltime = ts;
@@ -385,7 +313,7 @@ get_previous_release(struct graph_info *ginfo, struct rt_task_info *rtt_info,
                                                     &release, &deadline);
                 free_record(last_record);
                 last_record = record;
-                if (match && (pid == rtt_info->base.pid) && release <= time) {
+                if (match && (pid == rtt_info->pid) && release <= time) {
                         ret = record;
                         last_record = NULL;
                         *out_job = job;
@@ -422,7 +350,7 @@ static int get_time_info(struct graph_info *ginfo,
 
         /* Seek CPUs to first record after this time */
         *out_job = *out_release = *out_deadline = 0;
-        *out_record = find_record(ginfo, rtt_info->base.pid, time);
+        *out_record = find_record(ginfo, rtt_info->pid, time);
         if (!*out_record)
                 return 0;
 
@@ -466,20 +394,16 @@ static int rt_task_plot_event(struct graph_info *ginfo, struct graph_plot *plot,
                               struct record *record, struct plot_info *info)
 {
         struct rt_task_info *rtt_info = plot->private;
-        struct task_plot_info *task_info = &rtt_info->base;
-        int match, cpu;
+        int match;
 
         /* No more records, finish what we started */
         if (!record) {
-                if (task_info->last_cpu >= 0) {
+                if (rtt_info->last_cpu >= 0 &&
+                    rtt_info->run_time) {
                         info->box = TRUE;
-                        info->bstart = task_info->last_time;
+                        info->bstart = rtt_info->last_time;
                         info->bend = ginfo->view_end_time;
-                        info->bcolor = hash_cpu(task_info->last_cpu);
-                }
-                for (cpu = 0; cpu < ginfo->cpus; cpu++) {
-                        free_record(task_info->last_records[cpu]);
-                        task_info->last_records[cpu] = NULL;
+                        info->bcolor = hash_cpu(rtt_info->last_cpu);
                 }
                 return 0;
         }
@@ -493,25 +417,12 @@ static int rt_task_plot_event(struct graph_info *ginfo, struct graph_plot *plot,
                 try_resume(ginfo, rtt_info, record, info)      ||
                 try_other(ginfo, rtt_info, record, info);
 
-        /* This record is neither on our CPU nor related to us, useless */
-        if (!match && record->cpu != task_info->last_cpu) {
-                if (!task_info->last_records[record->cpu]) {
-                        task_info->last_records[record->cpu] = record;
-                        tracecmd_record_ref(record);
-                }
-                return 0;
-        }
-
-        if (!match) {
-                cpu = record->cpu;
-                /* We need some record, use this if none exist */
-                if (!task_info->last_records[cpu]) {
-                        free_record(task_info->last_records[cpu]);
-                        task_info->last_records[cpu] = record;
-                }
+        if (match) {
+                rtt_info->last_time = get_rts(ginfo, record);
+                rtt_info->last_cpu = record->cpu;
         }
 
-        return 1;
+        return match;
 }
 
 static void rt_task_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
@@ -520,8 +431,6 @@ static void rt_task_plot_start(struct graph_info *ginfo, struct graph_plot *plot
         int i;
         struct rt_task_info *rtt_info = plot->private;
 
-        task_plot_start(ginfo, plot, time);
-
         rtt_info->wcet = 0ULL;
         rtt_info->period = 0ULL;
         rtt_info->run_time = 0ULL;
@@ -537,7 +446,7 @@ static void rt_task_plot_start(struct graph_info *ginfo, struct graph_plot *plot
 static void rt_task_plot_destroy(struct graph_info *ginfo, struct graph_plot *plot)
 {
         struct rt_task_info *rtt_info = plot->private;
-        printf("Destroying plot %d\n", rtt_info->base.pid);
+        printf("Destroying plot %d\n", rtt_info->pid);
         free(rtt_info->label);
         task_plot_destroy(ginfo, plot);
 }
@@ -554,7 +463,7 @@ static int rt_task_plot_display_last_event(struct graph_info *ginfo,
         struct rt_task_info *rtt_info = plot->private;
 
         offsets = save_offsets(ginfo);
-        record = find_record(ginfo, rtt_info->base.pid, time);
+        record = find_display_record(ginfo, rtt_info->pid, time);
         restore_offsets(ginfo, offsets);
         if (!record)
                 return 0;
@@ -592,14 +501,14 @@ static int rt_task_plot_display_info(struct graph_info *ginfo,
         restore_offsets(ginfo, offsets);
 
         /* Show real-time data about time */
-        pid = rtt_info->base.pid;
+        pid = rtt_info->pid;
         comm = pevent_data_comm_from_pid(ginfo->pevent, pid);
         trace_seq_printf(s, "%s - %d:%d\n", comm, pid, job);
 
         if (record) {
                 rts = get_rts(ginfo, record);
+                eid = pevent_data_type(ginfo->pevent, record);
                 if (in_res(ginfo, rts, time)) {
-                        eid = pevent_data_type(ginfo->pevent, record);
                         event = pevent_data_event_from_type(ginfo->pevent, eid);
                         if (event) {
                                 trace_seq_puts(s, event->name);
@@ -626,14 +535,14 @@ static int rt_task_plot_match_time(struct graph_info *ginfo,
         struct rt_task_info *rtt_info = plot->private;
         int next_cpu, match, ret;
 
-        set_cpus_to_time(ginfo, time);
+        set_cpus_to_rts(ginfo, time);
 
         do {
                 free_record(record);
                 record = tracecmd_read_next_data(ginfo->handle, &next_cpu);
                 if (!record)
                         return 0;
-                match = record_matches_pid(ginfo, record, rtt_info->base.pid);
+                match = record_matches_pid(ginfo, record, rtt_info->pid);
         } while ((!match && get_rts(ginfo, record) < time + 1) ||
                  (match && get_rts(ginfo, record) < time));
 
@@ -649,14 +558,13 @@ rt_task_plot_find_record(struct graph_info *ginfo, struct graph_plot *plot,
                       unsigned long long time)
 {
         struct rt_task_info *rtt_info = plot->private;
-        return find_record(ginfo, rtt_info->base.pid, time);
+        return find_record(ginfo, rtt_info->pid, time);
 }
 
 
 static const struct plot_callbacks rt_task_cb = {
         .start                  = rt_task_plot_start,
         .destroy                = rt_task_plot_destroy,
-
         .plot_event             = rt_task_plot_event,
         .display_last_event     = rt_task_plot_display_last_event,
         .display_info           = rt_task_plot_display_info,
@@ -669,13 +577,25 @@ void rt_plot_task_update_callback(gboolean accept,
                                   gint *non_select,
                                   gpointer data)
 {
-        graph_tasks_update_callback(TASK_PLOT_RT, rt_plot_task,
+        graph_tasks_update_callback(PLOT_TYPE_RT_TASK, rt_plot_task,
                                     accept, selected, non_select, data);
 }
 
 void rt_plot_task_plotted(struct graph_info *ginfo, gint **plotted)
 {
-        graph_tasks_plotted(ginfo, TASK_PLOT_RT, plotted);
+        struct task_plot_info *task_info;
+        struct graph_plot *plot;
+        int count = 0;
+        int i;
+
+        *plotted = NULL;
+        for (i = 0; i < ginfo->plots; i++) {
+                plot = ginfo->plot_array[i];
+                if (plot->type != PLOT_TYPE_RT_TASK)
+                        continue;
+                task_info = plot->private;
+                trace_array_add(plotted, &count, task_info->pid);
+        }
 }
 
 void rt_plot_task(struct graph_info *ginfo, int pid, int pos)
@@ -684,29 +604,27 @@ void rt_plot_task(struct graph_info *ginfo, int pid, int pos)
         struct rt_task_info *rtt_info;
         struct graph_plot *plot;
         const char *comm;
-        char *label;
+        char *plot_label;
         int len;
 
         if (!find_task_list(rtinfo->tasks, pid))
                 die("Cannot create RT plot of non-RT task %d!\n", pid);
 
         rtt_info = malloc_or_die(sizeof(*rtt_info));
+        rtt_info->pid = pid;
         rtt_info->label = malloc_or_die(LLABEL);
 
-        init_task_plot_info(ginfo, &rtt_info->base, TASK_PLOT_RT, pid);
-
+        /* Create plot */
         comm = pevent_data_comm_from_pid(ginfo->pevent, pid);
         len = strlen(comm) + 100;
-        label = malloc_or_die(len);
-        snprintf(label, len, "*%s-%d", comm, pid);
-        rtt_info->pid = pid;
+        plot_label = malloc_or_die(len);
+        snprintf(plot_label, len, "*%s-%d", comm, pid);
+        plot = trace_graph_plot_insert(ginfo, pos, plot_label, PLOT_TYPE_RT_TASK,
+                                       &rt_task_cb, rtt_info);
+        free(plot_label);
 
-        printf("Created plot for %s-%d / %d %p\n", comm, pid, rtt_info->base.pid,
+        printf("Created plot for %s-%d / %d %p\n", comm, pid, rtt_info->pid,
                rtt_info);
 
-        plot = trace_graph_plot_insert(ginfo, pos, label, PLOT_TYPE_TASK,
-                                       &rt_task_cb, rtt_info);
-        free(label);
-
         trace_graph_plot_add_all_recs(ginfo, plot);
 }
diff --git a/rt-plot-task.h b/rt-plot-task.h
index a66de39..d3464e9 100644
--- a/rt-plot-task.h
+++ b/rt-plot-task.h
@@ -4,17 +4,18 @@
 #include "trace-plot-task.h"
 
 struct rt_task_info {
-        struct task_plot_info   base;
-
         int                     pid;
         unsigned long long      wcet;
         unsigned long long      period;
 
+        /* For drawing squares */
         unsigned long long      run_time;
         unsigned long long      block_time;
 
+        /* For managing state */
         int                     last_job;
         int                     last_cpu;
+        unsigned long long      last_time;
 
         /* Used to get around bugs(ish) */
         unsigned long long      first_rels[3];
diff --git a/trace-graph.h b/trace-graph.h
index ee57be6..1cb77b9 100644
--- a/trace-graph.h
+++ b/trace-graph.h
@@ -41,6 +41,7 @@ enum graph_plot_type {
         PLOT_TYPE_OTHER,
         PLOT_TYPE_CPU,
         PLOT_TYPE_TASK,
+        PLOT_TYPE_RT_TASK,
 };
 
 struct graph_plot;
diff --git a/trace-plot-task.c b/trace-plot-task.c
index abcdd89..d4b608b 100644
--- a/trace-plot-task.c
+++ b/trace-plot-task.c
@@ -713,10 +713,16 @@ static const struct plot_callbacks task_plot_cb = {
         .destroy                = task_plot_destroy
 };
 
-
-void graph_tasks_plotted(struct graph_info *ginfo,
-                         enum task_plot_type type,
-                         gint **plotted)
+/**
+ * graph_plot_task_plotted - return what tasks are plotted
+ * @ginfo: the graph info structure
+ * @plotted: returns an allocated array of gints holding the pids.
+ *  the last pid is -1, NULL, if none are.
+ *
+ * @plotted must be freed with free() after this is called.
+ */
+void graph_plot_task_plotted(struct graph_info *ginfo,
+                             gint **plotted)
 {
         struct task_plot_info *task_info;
         struct graph_plot *plot;
@@ -733,21 +739,7 @@ void graph_tasks_plotted(struct graph_info *ginfo,
         }
 }
 
-/**
- * graph_plot_task_plotted - return what tasks are plotted
- * @ginfo: the graph info structure
- * @plotted: returns an allocated array of gints holding the pids.
- *  the last pid is -1, NULL, if none are.
- *
- * @plotted must be freed with free() after this is called.
- */
-void graph_plot_task_plotted(struct graph_info *ginfo,
-                             gint **plotted)
-{
-        graph_tasks_plotted(ginfo, TASK_PLOT_LINUX, plotted);
-}
-
-void graph_tasks_update_callback(enum task_plot_type type,
+void graph_tasks_update_callback(enum graph_plot_type type,
                                  plot_task_cb plot_cb,
                                  gboolean accept,
                                  gint *selected,
@@ -778,12 +770,9 @@ void graph_tasks_update_callback(enum task_plot_type type,
          */
         for (i = ginfo->plots - 1; i >= 0; i--) {
                 plot = ginfo->plot_array[i];
-                if (plot->type != PLOT_TYPE_TASK)
+                if (plot->type != type)
                         continue;
-
                 task_info = plot->private;
-                if (task_info->type != type)
-                        continue;
 
                 /* If non are selected, then remove all */
                 if (!select_size) {
@@ -819,7 +808,7 @@ void graph_plot_task_update_callback(gboolean accept,
                                      gint *non_select,
                                      gpointer data)
 {
-        graph_tasks_update_callback(TASK_PLOT_LINUX, graph_plot_task,
+        graph_tasks_update_callback(PLOT_TYPE_TASK, graph_plot_task,
                                     accept, selected, non_select, data);
 }
 
@@ -850,17 +839,6 @@ void graph_plot_init_tasks(struct graph_info *ginfo)
                                 &task_plot_cb, task_info);
 }
 
-void init_task_plot_info(struct graph_info *ginfo,
-                         struct task_plot_info *task_info,
-                         enum task_plot_type type,
-                         int pid)
-{
-        task_info->last_records =
-                malloc_or_die(sizeof(struct record *) * ginfo->cpus);
-        task_info->pid = pid;
-        task_info->type = type;
-}
-
 void graph_plot_task(struct graph_info *ginfo, int pid, int pos)
 {
         struct task_plot_info *task_info;
@@ -870,8 +848,9 @@ void graph_plot_task(struct graph_info *ginfo, int pid, int pos)
         int len;
 
         task_info = malloc_or_die(sizeof(*task_info));
-
-        init_task_plot_info(ginfo, task_info, TASK_PLOT_LINUX, pid);
+        task_info->last_records =
+                malloc_or_die(sizeof(struct record *) * ginfo->cpus);
+        task_info->pid = pid;
 
         comm = pevent_data_comm_from_pid(ginfo->pevent, pid);
 
diff --git a/trace-plot-task.h b/trace-plot-task.h
index e050512..11cb4f8 100644
--- a/trace-plot-task.h
+++ b/trace-plot-task.h
@@ -8,12 +8,7 @@
 struct graph_info;
 struct graph_plot;
 struct plot_info;
-
-enum task_plot_type {
-        TASK_PLOT_OTHER,
-        TASK_PLOT_LINUX,
-        TASK_PLOT_RT
-};
+enum graph_plot_type;
 
 /**
  * struct task_plot_info - information for plotting a single task
@@ -25,7 +20,6 @@ enum task_plot_type {
  * @display_wake_time: as above, but reset under some circumstances
  * @wake_color:
  * @last_cpu: cpu task is currently running on
- * @type: type of task plot
  */
 struct task_plot_info {
         int                     pid;
@@ -36,7 +30,6 @@ struct task_plot_info {
         unsigned long long      display_wake_time;
         int                     wake_color;
         int                     last_cpu;
-        enum task_plot_type     type;
 };
 
 /* Querying records */
@@ -95,15 +88,10 @@ void graph_plot_init_tasks(struct graph_info *ginfo);
 
 /* Shared functionality for inheriting structs */
 typedef void (plot_task_cb)(struct graph_info *ginfo, int pid, int pos);
-void graph_tasks_update_callback(enum task_plot_type type,
+void graph_tasks_update_callback(enum graph_plot_type type,
                                  plot_task_cb plot_cb,
                                  gboolean accept,
                                  gint *selected,
                                  gint *non_select,
                                  gpointer data);
-void init_task_plot_info(struct graph_info *ginfo,
-                         struct task_plot_info *task_info,
-                         enum task_plot_type type, int pid);
-void graph_tasks_plotted(struct graph_info *ginfo, enum task_plot_type type,
-                         gint **plotted);
 #endif