rt-graph: real-time tasks can be added / removed from the graph

Currently they copy the functionality of regular task.

12 files changed, 635 insertions, 129 deletions

diff --git a/Documentation/structure.txt b/Documentation/structure.txt
new file mode 100644
index 0000000..adee54d
--- /dev/null
+++ b/Documentation/structure.txt
@@ -0,0 +1,225 @@
+
+Can't do this until cpus set up!
+
+0. Load all events w/ proper stuff
+
+1. Create list of rt_tasks
+2. Create seperate dailog for rt tasks w/ a callback.
+3. Allow dialog to be filtered.
+4. Create dummy task thing that just says hi.
+5. Make it print out when it reads stuff.
+6. Draw shit
+7. Draw new shit.
+
+
+struct trace-graph.h {
+ /* - header file for generic graphers */
+
+/*  - What is returned for drawing */
+/*  struct plot_info; */
+
+/*  - what you can customize */
+/*  struct plot_callbacks; */
+/*   - customized in trace-*-plot.c */
+
+/*  - one of these per trace-*-plot instantiation */
+/*  struct graph_plot; */
+/*   void* private is per trace-*-plot */
+/*   *cb (callbacks) is the callbacks */
+
+
+/*  struct graph_callbacks; */
+/*  struct plot_list; */
+/*  struct plot_hash; */
+
+/*  /\* Current state of the displayed graph AS A WHOLE *\/ */
+  struct graph_info {
+    handle; /* input handle */
+  };
+
+/*  - create with trace_graph_plot_insert */
+
+};
+
+struct parse-events.h {
+  /* Can write shit into it person by person */
+  struct trace_seq;
+};
+
+struct unknown {
+
+};
+
+struct trace-graph.c {
+
+};
+
+/* trace-graph.c */
+ 
+
+
+struct trace-plot-task.c {
+
+  /*** PRIVATE DATA ***/
+
+  /* Private to each task plot */
+  struct task_plot_info {
+    pid /* per task */
+    /* Other current things, lotta last whatevs */
+  }
+
+  /*** PRIVATE METHODS ****/
+
+  /* Return true if the record (which is for this task) is a sched_switch
+   * and the data held is the previous state?? */
+  is_running(ginfo, record);
+
+  /* Return true if the record is:
+   * a sched_switch to our pid or from our pid, is_sched = TRUE
+   * a wakeup, if we are waking up, wakeup = TRUE
+   * from our pid, all fALSE
+   */
+  record_matches_pid(ginfo, record, match_pid, &pid, &sched_pid, &is_sched, &wakeup);
+
+
+  /* Sets cpu to given time. Read till that time is passed, freeing everytning
+   * on the way.
+   * If we reach a record at or past our time, set cursor to that time.
+   */
+  set_cpu_to_time(cpu, ginfo, time);
+
+  /* Call above on all cpus */
+  set_cpus_to_time(ginfo, time);
+
+  /* Return struct w/ array holding current record offset at each cpu */
+  save_offsets(ginfo);
+
+  /* Set cursor to each offset, if present. Otherwise, put at end */
+  restore_offsets(ginfo, offsets);
+
+  /* Return first record after time which is from our pid */
+  find_record(ginfo, pid, time);
+
+  /* Updates last_whatevers in task info */
+  update_last_record(ginfo, task_plot_info, record);
+
+  /* Reads backwards until it finds a matching record */
+  find_previous_record(ginfo, start_record, pid, cpu);
+
+  get_display_record(ginfo, pid, time);
+
+  /**** PUBLIC METHODS *****/
+
+  /* Basically reset as though you just started reading */
+  task_plot_start(ginfo, plot, time);
+
+  /* Load the next record for me at or after that time */
+  task_plot_match_time(ginfo, plot, time);
+
+  /* Get record at time, print info */
+  task_plot_display_last_event(info, plot, trace_seq s, time);
+
+  /* Always draws a line of the color of the pid. Always.
+   * Then update_last_record.
+   * If record is null, times up, just finish our shit and return.
+   * If was running, and now wakeup, that means another task woke up
+   *   We need to end our gd box. If it was us waking up,no box.
+   *   return.
+   * If a match
+   *   If a new cpu, see if we switched cpu. if so, create a box w/
+   *     proper color for LAST cpu, end it here.
+   *   If scheduled, but we weren't currently running, we are now.
+   *     Update the last bullshit. If we had a wake time, that means
+   *     our wakeup turned into a run. Draw an empty box where we were
+   *     awake but not running. Otherwise, reset wake time.
+   *   Else if we haven't created a new box, (ie switched cpus), we got
+   *     switched out. Create a goddamn box.
+   *   Return
+   * If no previous last_records on this cpu, put this record there.
+   * If there was a last cpu, but no match, somehow we aren't running.
+   *   Finish the box.
+   */
+  task_plot_event(ginfo, plot,r ecord, info);
+
+  /* Just frontend for find_record */
+  task_plot_find_record(ginfo, plot, time);
+
+  /* Print out event info if in current resolution */
+  task_plot_display_info(ginfo, plot, sequence s, time);
+
+  /* Free private info */
+  task_plot_destroy(info, plot);
+
+
+  /*** STATIC METHODS ***/
+
+  /* Return what tasks are plotted */
+  void graph_plot_task_plotted(ginfo, **plotted);
+
+  /* Called when task is clicked or removed */
+  graph_plot_task_update_callback(accept, selected, non_selct, data);
+
+  /* Create a plot for a single task, insert into plot */
+  graph_plot_task(ginfo, pid, pos);
+
+};
+
+struct trace-plot-cpu.c{
+  /*** DATA ***/
+  struct cpu_plot_info {
+    cpu, last_time, last_pid, *last_record;
+  };
+
+  /*** PRIVATE ***/
+  /* Hashes for pid value, but if idle (aka 0), returns black) */
+  hash_pid(val);
+
+  /* Sets cpu near time, reads until time is passed, returns last record */
+  get_record_from_time(ginfo, cpu, time);
+
+  /* Return 1 if the record should be skipped */
+  filter_record(ginfo, record, &orig_pid, &sched_pid, &sched_switch);
+
+  /* Update last_pid, last_record, and last_time */
+  update_last_record(ginfo, cpu_info, record);
+
+  /* Uh eh hrm? */
+  find_record_on_cpu(ginfo, cpu, time);
+
+
+  /*** PUBLIC ***/
+  /* Gets record around time. Return 1 if exact match */
+  cpu_plot_match_time(ginfo, plot, time);
+
+  /* Find first non-filtered event after time, write out info into s */
+  cpu_plot_display_last_event(ginfo, plot, sequence s, time);
+
+  /* Prepare for liftoff ! */
+  cpu_plot_start(ginfo, plot, time);
+
+  /* Generate stuff as needed */
+  cpu_plot_event(ginfo, plot, record, info);
+
+  /* Call find record to get a record in this time */
+  cpu_plot_find_record(ginfo, plot, time);
+
+  /* Write out info for record at or before time */
+  cpu_plot_display_info(gino, plot, s, time);
+
+  /* You get it */
+  cpu_plot_destroy(ginfo, plot);
+
+  /*** STATIC ***/
+  /* Create cpu plot, add to trace graph */
+  add_cpu_plot(ginfo, cpu);
+
+  /* Return cpus plotted in cpu_mask */
+  graph_plot_cpus_plotted(ginfo, *all_cpus, **cpu_mask);
+
+  /* Remove unselected plots, add selected plots */
+  graph_plot_cpus_update_callback(accept, all_cpus, selected_cpu_mast, data);
+
+  /* Automatigically add all cpus */
+  graph_plot_init_cpus();
+
+}
diff --git a/kernel-shark.c b/kernel-shark.c
index e0c123a..b24e3b6 100644
--- a/kernel-shark.c
+++ b/kernel-shark.c
@@ -150,17 +150,6 @@ static void update_tree_view_filters(struct shark_info *info,
 
 /* graph callbacks */
 
-/* convert_nano() and print_time() are copied from trace-graph.c for debugging
-   purposes, and should be deleted when this is complete (or merged with
-   trace-graph.c */
-
-static void convert_nano(unsigned long long time, unsigned long *sec,
-                         unsigned long *usec)
-{
-        *sec = time / 1000000000ULL;
-        *usec = (time / 1000) % 1000000;
-}
-
 static void print_time(unsigned long long time)
 {
         unsigned long sec, usec;
@@ -1292,10 +1281,10 @@ plot_rt_tasks_clicked (gpointer data)
 
         rtinfo = &ginfo->rtinfo;
         tasks = task_list_pids(rtinfo->tasks);
-        rt_plot_task_plotted(rtinfo, &selected);
+        rt_plot_task_plotted(ginfo, &selected);
 
         trace_task_dialog(ginfo->handle, tasks, selected,
-                          rt_plot_task_update_callback, rtinfo);
+                          rt_plot_task_update_callback, ginfo);
         free(tasks);
         free(selected);
 }
diff --git a/rt-graph.h b/rt-graph.h
index 3037301..3357b52 100644
--- a/rt-graph.h
+++ b/rt-graph.h
@@ -2,8 +2,9 @@
 #define _RT_GRAPH_H
 
 #include <gtk/gtk.h>
-#include "trace-cmd.h"
 #include "task-list.h"
+#include "trace-cmd.h"
+#include "rt-plot-task.h"
 
 struct rt_graph_info {
 
@@ -59,12 +60,4 @@ 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);
 
-/* Metadata */
-void rt_plot_task_plotted(struct rt_graph_info *rt_info, gint **plotted);
-
-/* Callbacks for managing task list */
-void rt_plot_task_update_callback(gboolean accept, gint *selected,
-                                  gint *non_select, gpointer data);
-void rt_plot_task_plotted(struct rt_graph_info *rtinfo, gint **plotted);
-
 #endif
diff --git a/rt-plot-task.c b/rt-plot-task.c
new file mode 100644
index 0000000..d63c872
--- /dev/null
+++ b/rt-plot-task.c
@@ -0,0 +1,54 @@
+#include "trace-graph.h"
+
+static const struct plot_callbacks rt_task_cb = {
+        .match_time             = task_plot_match_time,
+        .plot_event             = task_plot_event,
+        .start                  = task_plot_start,
+        .display_last_event     = task_plot_display_last_event,
+        .find_record            = task_plot_find_record,
+        .display_info           = task_plot_display_info,
+        .destroy                = task_plot_destroy
+};
+
+void rt_plot_task_update_callback(gboolean accept,
+                                  gint *selected,
+                                  gint *non_select,
+                                  gpointer data)
+{
+        graph_tasks_update_callback(TASK_PLOT_RT, 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);
+}
+
+void rt_plot_task(struct graph_info *ginfo, int pid, int pos)
+{
+        struct rt_graph_info *rtinfo = &ginfo->rtinfo;
+        struct rt_task_info *rt_task;
+        struct graph_plot *plot;
+        const char *comm;
+        char *label;
+        int len;
+
+        if (!find_task_list(rtinfo->tasks, pid))
+                die("Cannot create RT plot of non-RT task %d!\n", pid);
+
+        rt_task = malloc_or_die(sizeof(*rt_task));
+
+        init_task_plot_info(ginfo, &rt_task->base, TASK_PLOT_RT, pid);
+
+        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);
+
+        plot = trace_graph_plot_insert(ginfo, pos, label, PLOT_TYPE_TASK,
+                                       &rt_task_cb, rt_task);
+        free(label);
+
+        trace_graph_plot_add_all_recs(ginfo, plot);
+}
+
diff --git a/rt-plot-task.h b/rt-plot-task.h
new file mode 100644
index 0000000..4cb957a
--- /dev/null
+++ b/rt-plot-task.h
@@ -0,0 +1,22 @@
+#ifndef __RT_PLOT_TASK_H
+#define __RT_PLOT_TASK_H
+
+#include "trace-plot-task.h"
+
+struct rt_task_info {
+        struct task_plot_info   base;
+        unsigned long long      wcet;
+        unsigned long long      period;
+        unsigned long long      block_time;
+        int                     last_job;
+};
+
+void rt_plot_task(struct graph_info *ginfo, int pid, int pos);
+void rt_plot_task_plotted(struct graph_info *ginfo,
+                          gint **plotted);
+void rt_plot_task_update_callback(gboolean accept,
+                                  gint *selected,
+                                  gint *non_select,
+                                  gpointer data);
+
+#endif
diff --git a/task-list.c b/task-list.c
new file mode 100644
index 0000000..4c820bf
--- /dev/null
+++ b/task-list.c
@@ -0,0 +1,99 @@
+#include "task-list.h"
+
+static guint get_task_hash_key(gint pid)
+{
+        return trace_hash(pid) % TASK_HASH_SIZE;
+}
+
+struct task_list *find_task_hash(struct task_list **tasks,
+                                 gint key, gint pid)
+{
+        struct task_list *list;
+
+        for (list = tasks[key]; list; list = list->next) {
+                if (list->pid == pid)
+                        return list;
+        }
+
+        return NULL;
+}
+
+/**
+ * find_task_list - return task_list node for pid, or NULL if not present
+ */
+struct task_list *find_task_list(struct task_list **tasks, gint pid)
+{
+        guint key = get_task_hash_key(pid);
+        return find_task_hash(tasks, key, pid);
+}
+
+/**
+ * add_task_hash - add pid to a task_list
+ * @tasks: The head of the task_list
+ * @pid: The pid to add
+ *
+ * Return the list entry of the added task
+ */
+struct task_list *add_task_hash(struct task_list **tasks, int pid)
+{
+        struct task_list *list;
+        guint key = get_task_hash_key(pid);
+
+        list = find_task_hash(tasks, key, pid);
+        if (list)
+                return list;
+
+        list = malloc_or_die(sizeof(*list));
+        list->pid = pid;
+        list->next = tasks[key];
+        tasks[key] = list;
+
+        return list;
+}
+
+/**
+ * free_task_hash - free all nodes in a task_list
+ */
+void free_task_hash(struct task_list **tasks)
+{
+        struct task_list *list;
+        int i;
+
+        for (i = 0; i < TASK_HASH_SIZE; i++) {
+                while (tasks[i]) {
+                        list = tasks[i];
+                        tasks[i] = list->next;
+                        free(list);
+                }
+        }
+}
+
+/**
+ * task_list_pids - return an allocated list of all found tasks
+ * @ginfo: The graph info structure
+ *
+ * Returns an allocated list of pids found in the graph, ending
+ * with a -1. This array must be freed with free().
+ */
+gint *task_list_pids(struct task_list **tasks)
+{
+        struct task_list *list;
+        gint *pids;
+        gint count = 0;
+        gint i;
+
+        for (i = 0; i < TASK_HASH_SIZE; i++) {
+                list = tasks[i];
+                while (list) {
+                        if (count)
+                                pids = realloc(pids, sizeof(*pids) * (count + 2));
+                        else
+                                pids = malloc(sizeof(*pids) * 2);
+                        pids[count++] = list->pid;
+                        pids[count] = -1;
+                        list = list->next;
+                }
+        }
+
+        return pids;
+}
diff --git a/task-list.h b/task-list.h
new file mode 100644
index 0000000..eb1213b
--- /dev/null
+++ b/task-list.h
@@ -0,0 +1,20 @@
+#ifndef __TASK_LIST_H
+#define __TASK_LIST_H
+
+#include <gtk/gtk.h>
+#include "trace-cmd.h"
+#include "trace-hash.h"
+
+#define TASK_HASH_SIZE 1024
+
+struct task_list {
+        struct task_list        *next;
+        gint                    pid;
+};
+
+struct task_list* find_task_list(struct task_list **tasks, int pid);
+struct task_list* add_task_hash(struct task_list **tasks, int pid);
+void free_task_hash(struct task_list **tasks);
+gint* task_list_pids(struct task_list **tasks);
+
+#endif
diff --git a/trace-graph.c b/trace-graph.c
index 819482e..2cf7a95 100644
--- a/trace-graph.c
+++ b/trace-graph.c
@@ -70,13 +70,6 @@ static GdkGC *red;
 static void redraw_pixmap_backend(struct graph_info *ginfo);
 static void update_label_window(struct graph_info *ginfo);
 
-static void convert_nano(unsigned long long time, unsigned long *sec,
-                         unsigned long *usec)
-{
-        *sec = time / 1000000000ULL;
-        *usec = (time / 1000) % 1000000;
-}
-
 static int convert_time_to_x(struct graph_info *ginfo, guint64 time)
 {
         if (time < ginfo->view_start_time)
diff --git a/trace-graph.h b/trace-graph.h
index 92d9883..a0c5c54 100644
--- a/trace-graph.h
+++ b/trace-graph.h
@@ -27,6 +27,7 @@
 #include "trace-xml.h"
 #include "task-list.h"
 #include "rt-graph.h"
+#include "trace-plot-task.h"
 
 struct graph_info;
 
@@ -389,14 +390,26 @@ void graph_plot_cpus_update_callback(gboolean accept,
                                      guint64 *selected_cpu_mask,
                                      gpointer data);
 
-/* task plot */
-void graph_plot_task(struct graph_info *ginfo, int pid, int pos);
-void graph_plot_task_update_callback(gboolean accept,
-                                     gint *selected,
-                                     gint *non_select,
-                                     gpointer data);
-void graph_plot_task_plotted(struct graph_info *ginfo,
-                             gint **plotted);
+static inline void convert_nano(unsigned long long time, unsigned long *sec,
+                                unsigned long *usec)
+{
+        *sec = time / 1000000000ULL;
+        *usec = (time / 1000) % 1000000;
+}
+
+static inline gint hash_pid(gint val)
+{
+        /* idle always gets black */
+        if (!val)
+                return 0;
+        return trace_hash(val);
+}
+
+static inline int hash_cpu(int cpu)
+{
+        cpu = (cpu << 3) + cpu * 21;
+        return trace_hash(cpu);
+}
 
 
 #endif /* _TRACE_GRAPH_H */
diff --git a/trace-plot-cpu.c b/trace-plot-cpu.c
index 5dea225..c7a37f5 100644
--- a/trace-plot-cpu.c
+++ b/trace-plot-cpu.c
@@ -30,22 +30,6 @@ struct cpu_plot_info {
         struct record           *last_record;
 };
 
-static gint hash_pid(gint val)
-{
-        /* idle always gets black */
-        if (!val)
-                return 0;
-
-        return trace_hash(val);
-}
-
-static void convert_nano(unsigned long long time, unsigned long *sec,
-                         unsigned long *usec)
-{
-        *sec = time / 1000000000ULL;
-        *usec = (time / 1000) % 1000000;
-}
-
 static struct record *get_record_from_time(struct graph_info *ginfo, int cpu,
                                            unsigned long long time)
 {
diff --git a/trace-plot-task.c b/trace-plot-task.c
index 9ca97a3..e4ac13a 100644
--- a/trace-plot-task.c
+++ b/trace-plot-task.c
@@ -26,41 +26,7 @@
 #define RED 0xff
 #define GREEN (0xff<<16)
 
-struct task_plot_info {
-        int                     pid;
-        struct cpu_data         *cpu_data;
-        struct record           **last_records;
-        unsigned long long      last_time;
-        unsigned long long      wake_time;
-        unsigned long long      display_wake_time;
-        int                     wake_color;
-        int                     last_cpu;
-};
-
-static void convert_nano(unsigned long long time, unsigned long *sec,
-                         unsigned long *usec)
-{
-        *sec = time / 1000000000ULL;
-        *usec = (time / 1000) % 1000000;
-}
-
-static gint hash_pid(gint val)
-{
-        /* idle always gets black */
-        if (!val)
-                return 0;
-
-        return trace_hash(val);
-}
-
-static int hash_cpu(int cpu)
-{
-        cpu = (cpu << 3) + cpu * 21;
- 
-        return trace_hash(cpu);
-}
-
-static gboolean is_running(struct graph_info *ginfo, struct record *record)
+gboolean is_running(struct graph_info *ginfo, struct record *record)
 {
         unsigned long long val;
         int id;
@@ -73,7 +39,7 @@ static gboolean is_running(struct graph_info *ginfo, struct record *record)
         return val ? FALSE : TRUE;
 }
 
-static gboolean record_matches_pid(struct graph_info *ginfo,
+gboolean record_matches_pid(struct graph_info *ginfo,
                                    struct record *record, int match_pid,
                                    int *pid, int *sched_pid,
                                    gboolean *is_sched,
@@ -107,7 +73,7 @@ static gboolean record_matches_pid(struct graph_info *ginfo,
         return FALSE;
 }
 
-static void set_cpu_to_time(int cpu, struct graph_info *ginfo, unsigned long long time)
+void set_cpu_to_time(int cpu, struct graph_info *ginfo, unsigned long long time)
 {
         struct record *record;
 
@@ -126,7 +92,7 @@ static void set_cpu_to_time(int cpu, struct graph_info *ginfo, unsigned long lon
                 tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, time);
 }
 
-static void set_cpus_to_time(struct graph_info *ginfo, unsigned long long time)
+void set_cpus_to_time(struct graph_info *ginfo, unsigned long long time)
 {
         int cpu;
 
@@ -134,7 +100,7 @@ static void set_cpus_to_time(struct graph_info *ginfo, unsigned long long time)
                 set_cpu_to_time(cpu, ginfo, time);
 }
 
-static int task_plot_match_time(struct graph_info *ginfo, struct graph_plot *plot,
+int task_plot_match_time(struct graph_info *ginfo, struct graph_plot *plot,
                                unsigned long long time)
 {
         struct task_plot_info *task_info = plot->private;
@@ -173,11 +139,7 @@ static int task_plot_match_time(struct graph_info *ginfo, struct graph_plot *plo
         return ret;
 }
 
-struct offset_cache {
-        guint64 *offsets;
-};
-
-static struct offset_cache *save_offsets(struct graph_info *ginfo)
+struct offset_cache *save_offsets(struct graph_info *ginfo)
 {
         struct offset_cache *offsets;
         struct record *record;
@@ -196,7 +158,7 @@ static struct offset_cache *save_offsets(struct graph_info *ginfo)
         return offsets;
 }
 
-static void restore_offsets(struct graph_info *ginfo, struct offset_cache *offsets)
+void restore_offsets(struct graph_info *ginfo, struct offset_cache *offsets)
 {
         struct record *record;
         int cpu;
@@ -215,7 +177,7 @@ static void restore_offsets(struct graph_info *ginfo, struct offset_cache *offse
         free(offsets);
 }
 
-static struct record *
+struct record *
 find_record(struct graph_info *ginfo, gint pid, guint64 time)
 {
         struct record *record = NULL;
@@ -245,7 +207,7 @@ find_record(struct graph_info *ginfo, gint pid, guint64 time)
         return record;
 }
 
-static int task_plot_display_last_event(struct graph_info *ginfo,
+int task_plot_display_last_event(struct graph_info *ginfo,
                                         struct graph_plot *plot,
                                         struct trace_seq *s,
                                         unsigned long long time)
@@ -318,7 +280,7 @@ static int task_plot_display_last_event(struct graph_info *ginfo,
         return 1;
 }
 
-static void task_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
+void task_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
                             unsigned long long time)
 {
         struct task_plot_info *task_info = plot->private;
@@ -331,7 +293,7 @@ static void task_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
         task_info->display_wake_time = 0ULL;
 }
 
-static void update_last_record(struct graph_info *ginfo,
+void update_last_task_record(struct graph_info *ginfo,
                                struct task_plot_info *task_info,
                                struct record *record)
 {
@@ -363,7 +325,7 @@ static void update_last_record(struct graph_info *ginfo,
                         continue;
 
                 if (cpu == this_cpu) {
-                        static int once;
+                        int once;
 
                         trecord = tracecmd_read_prev(handle, record);
                         /* Set cpu cursor back to what it was  */
@@ -374,7 +336,7 @@ static void update_last_record(struct graph_info *ginfo,
                         }
                         free_record(saved);
                 } else {
-                        static int once;
+                        int once;
 
                         saved = tracecmd_read_data(handle, cpu);
                         set_cpu_to_time(cpu, ginfo, ts);
@@ -412,7 +374,7 @@ static void update_last_record(struct graph_info *ginfo,
         }
 }
 
-static int task_plot_event(struct graph_info *ginfo,
+int task_plot_event(struct graph_info *ginfo,
                            struct graph_plot *plot,
                            struct record *record,
                            struct plot_info *info)
@@ -429,7 +391,7 @@ static int task_plot_event(struct graph_info *ginfo,
         pid = task_info->pid;
 
         if (!record) {
-                update_last_record(ginfo, task_info, record);
+                update_last_task_record(ginfo, task_info, record);
                 /* no more records, finish a box if one was started */
                 if (task_info->last_cpu >= 0) {
                         info->box = TRUE;
@@ -468,7 +430,7 @@ static int task_plot_event(struct graph_info *ginfo,
                  * viewable range. Search to see if one exists, and if
                  * it is the record we want to match.
                  */
-                update_last_record(ginfo, task_info, record);
+                update_last_task_record(ginfo, task_info, record);
 
                 if (is_wakeup) {
                         /* Wake up but not task */
@@ -555,7 +517,7 @@ static int task_plot_event(struct graph_info *ginfo,
 }
 
 
-static struct record *
+struct record *
 task_plot_find_record(struct graph_info *ginfo, struct graph_plot *plot,
                       unsigned long long time)
 {
@@ -569,7 +531,7 @@ task_plot_find_record(struct graph_info *ginfo, struct graph_plot *plot,
 
 #define MAX_SEARCH 20
 
-static struct record *
+struct record *
 find_previous_record(struct graph_info *ginfo, struct record *start_record,
                      int pid, int cpu)
 {
@@ -609,7 +571,7 @@ find_previous_record(struct graph_info *ginfo, struct record *start_record,
         return record;
 }
 
-static struct record *
+struct record *
 get_display_record(struct graph_info *ginfo, int pid, unsigned long long time)
 {
         struct record *record;
@@ -752,16 +714,10 @@ static const struct plot_callbacks task_plot_cb = {
         .destroy                = task_plot_destroy
 };
 
-/**
- * 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)
+
+void graph_tasks_plotted(struct graph_info *ginfo,
+                         enum task_plot_type type,
+                         gint **plotted)
 {
         struct task_plot_info *task_info;
         struct graph_plot *plot;
@@ -778,10 +734,26 @@ void graph_plot_task_plotted(struct graph_info *ginfo,
         }
 }
 
-void graph_plot_task_update_callback(gboolean accept,
-                                     gint *selected,
-                                     gint *non_select,
-                                     gpointer data)
+/**
+ * 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,
+                                 plot_task_cb plot_cb,
+                                 gboolean accept,
+                                 gint *selected,
+                                 gint *non_select,
+                                 gpointer data)
 {
         struct graph_info *ginfo = data;
         struct task_plot_info *task_info;
@@ -809,12 +781,16 @@ void graph_plot_task_update_callback(gboolean accept,
                 plot = ginfo->plot_array[i];
                 if (plot->type != PLOT_TYPE_TASK)
                         continue;
+
+                task_info = plot->private;
+                if (task_info->type != type)
+                        continue;
+
                 /* If non are selected, then remove all */
                 if (!select_size) {
                         trace_graph_plot_remove(ginfo, plot);
                         continue;
                 }
-                task_info = plot->private;
                 ptr = bsearch(&task_info->pid, selected, select_size,
                               sizeof(gint), id_cmp);
                 if (ptr) {
@@ -834,11 +810,20 @@ void graph_plot_task_update_callback(gboolean accept,
 
         /* Now add any plots that need to be added */
         for (i = 0; i < select_size; i++)
-                graph_plot_task(ginfo, selected[i], ginfo->plots);
+                plot_cb(ginfo, selected[i], ginfo->plots);
 
         trace_graph_refresh(ginfo);
 }
 
+void graph_plot_task_update_callback(gboolean accept,
+                                     gint *selected,
+                                     gint *non_select,
+                                     gpointer data)
+{
+        graph_tasks_update_callback(TASK_PLOT_LINUX, graph_plot_task,
+                                    accept, selected, non_select, data);
+}
+
 void graph_plot_init_tasks(struct graph_info *ginfo)
 {
         struct task_plot_info *task_info;
@@ -866,6 +851,17 @@ 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;
@@ -875,9 +871,9 @@ void graph_plot_task(struct graph_info *ginfo, int pid, int pos)
         int len;
 
         task_info = malloc_or_die(sizeof(*task_info));
-        task_info->last_records =
-                malloc_or_die(sizeof(struct record *) * ginfo->cpus);
-        task_info->pid = pid;
+
+        init_task_plot_info(ginfo, task_info, TASK_PLOT_LINUX, pid);
+
         comm = pevent_data_comm_from_pid(ginfo->pevent, pid);
 
         len = strlen(comm) + 100;
diff --git a/trace-plot-task.h b/trace-plot-task.h
new file mode 100644
index 0000000..3232339
--- /dev/null
+++ b/trace-plot-task.h
@@ -0,0 +1,118 @@
+#ifndef __TRACE_PLOT_TASK_H
+#define __TRACE_PLOT_TASK_H
+
+#include <gtk/gtk.h>
+
+#include "trace-cmd.h"
+
+struct graph_info;
+struct graph_plot;
+struct plot_info;
+
+enum task_plot_type {
+        TASK_PLOT_OTHER,
+        TASK_PLOT_LINUX,
+        TASK_PLOT_RT
+};
+
+/**
+ * struct task_plot_info - information for plotting a single task
+ * @pid: pid to plot
+ * @cpu_data: state of each cpu
+ * @last_records: cache of recently accessed records
+ * @last_time: time of last record seen by this task graph
+ * @wake_time: time task resumed execution
+ * @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;
+        struct cpu_data         *cpu_data;
+        struct record           **last_records;
+        unsigned long long      last_time;
+        unsigned long long      wake_time;
+        unsigned long long      display_wake_time;
+        int                     wake_color;
+        int                     last_cpu;
+        enum task_plot_type     type;
+};
+
+/* Querying records */
+gboolean is_running(struct graph_info *ginfo, struct record *record);
+gboolean record_matches_pid(struct graph_info *ginfo, struct record *record,
+                            int match_pid, int *pid, int *sched_pid,
+                            gboolean *is_sched, gboolean *wakeup);
+
+/* State maintenance */
+void update_last_task_record(struct graph_info *ginfo, struct task_plot_info *task_info,
+                             struct record *record);
+
+/* Searching for records */
+#define MAX_SEARCH 20
+struct record *
+find_record(struct graph_info *ginfo, gint pid, guint64 time);
+struct record *find_previous_record(struct graph_info *ginfo,
+                                           struct record *start_record,
+                                           int pid, int cpu);
+struct record *get_display_record(struct graph_info *ginfo, int pid,
+                                  unsigned long long time);
+
+/* Seeking in data file */
+void set_cpu_to_time(int cpu, struct graph_info *ginfo, unsigned long long time);
+void set_cpus_to_time(struct graph_info *ginfo, unsigned long long time);
+
+/* Saving / restoring state */
+struct offset_cache {
+        guint64 *offsets;
+};
+struct offset_cache *save_offsets(struct graph_info *ginfo);
+void restore_offsets(struct graph_info *ginfo, struct offset_cache *offsets);
+
+/* Callbacks */
+int task_plot_match_time(struct graph_info *ginfo, struct graph_plot *plot,
+                         unsigned long long time);
+int task_plot_display_last_event(struct graph_info *ginfo,
+                                 struct graph_plot *plot,
+                                 struct trace_seq *s,
+                                 unsigned long long time);
+void task_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
+                     unsigned long long time);
+int task_plot_event(struct graph_info *ginfo, struct graph_plot *plot,
+                    struct record *record, struct plot_info *info);
+struct record *task_plot_find_record(struct graph_info *ginfo,
+                                     struct graph_plot *plot,
+                                     unsigned long long time);
+int task_plot_display_info(struct graph_info *ginfo,
+                           struct graph_plot *plot,
+                           struct trace_seq *s,
+                           unsigned long long time);
+void task_plot_destroy(struct graph_info *ginfo, struct graph_plot *plot);
+
+/* Plot management */
+void graph_plot_task(struct graph_info *ginfo, int pid, int pos);
+void graph_plot_task_plotted(struct graph_info *ginfo,
+                             gint **plotted);
+
+void graph_plot_task_update_callback(gboolean accept,
+                                     gint *selected,
+                                     gint *non_select,
+                                     gpointer data);
+
+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,
+                                 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