trace-graph: Iterate over all records for all plots

Change the code to iterate once down all records to create all plots.
Use the cpu_hash, task_hash and all_recs to find what plot cares about what
data.

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

5 files changed, 204 insertions, 172 deletions

diff --git a/trace-graph.c b/trace-graph.c
index f1f0a2c..2ad7c2f 100644
--- a/trace-graph.c
+++ b/trace-graph.c
@@ -1406,25 +1406,13 @@ static void draw_plot_box(struct graph_info *ginfo, int i,
                            x2 - x1, PLOT_BOX_SIZE);
 }
 
-static void draw_plot(struct graph_info *ginfo, gint i,
-                      gint new_width, gboolean read_comms)
+static void draw_plot(struct graph_info *ginfo, struct graph_plot *plot,
+                      struct record *record)
 {
         static PangoFontDescription *font;
         PangoLayout *layout;
-        gint height = PLOT_LINE(i);
-        struct graph_plot *plot = ginfo->plot_array[i];
-        static GdkGC *gc;
         static gint width_16;
-        guint64 ts;
-        gint lcolor;
-        gint bcolor;
-        gint last_color = -1;
-        gboolean box;
-        gboolean line;
-        unsigned long long ltime;
-        unsigned long long bstart;
-        unsigned long long bend;
-        gint p1 = 0, p2 = 0, p3 = 0;
+        struct plot_info info;
         gint x;
 
         /* Calculate the size of 16 characters */
@@ -1442,87 +1430,117 @@ static void draw_plot(struct graph_info *ginfo, gint i,
                 g_object_unref(layout);
         }
 
-        if (!gc)
-                gc = gdk_gc_new(ginfo->draw->window);
+        trace_graph_plot_event(ginfo, plot, record, &info);
 
-        gdk_draw_line(ginfo->curr_pixmap, ginfo->draw->style->black_gc,
-                      0, height, new_width, height);
+        if (info.box) {
+                if (info.bcolor != plot->last_color) {
+                        plot->last_color = info.bcolor;
+                        set_color(ginfo->draw, plot->gc, plot->last_color);
+                }
 
-        ts = ginfo->view_start_time;
+                draw_plot_box(ginfo, plot->pos, info.bstart, info.bend, plot->gc);
+        }
 
-        trace_graph_plot_start(ginfo, plot, ts);
+        if (info.line) {
+                if (info.lcolor != plot->last_color) {
+                        plot->last_color = info.lcolor;
+                        set_color(ginfo->draw, plot->gc, plot->last_color);
+                }
 
-        set_color(ginfo->draw, gc, last_color);
+                x = draw_plot_line(ginfo, plot->pos, info.ltime, plot->gc);
 
-        while (trace_graph_plot_event(ginfo, plot,
-                                      &line, &lcolor, &ltime,
-                                      &box, &bcolor, &bstart, &bend)) {
+                /* Figure out if we can show the text for the previous record */
 
-                /* really should not happen */
-                if (!line && !box)
-                        continue;
+                plot->p3 = x;
 
-                if (box) {
-                        if (bcolor != last_color) {
-                                last_color = bcolor;
-                                set_color(ginfo->draw, gc, last_color);
-                        }
+                /* Make sure p2 will be non-zero the next iteration */
+                if (!plot->p3)
+                        plot->p3 = 1;
 
-                        draw_plot_box(ginfo, i, bstart, bend, gc);
-                }
+                /* first record, continue */
+                if (plot->p2)
+                        plot->p2 = draw_event_label(ginfo, plot->pos,
+                                                    plot->p1, plot->p2, plot->p3, width_16, font);
 
-                if (line) {
+                plot->p1 = plot->p2;
+                plot->p2 = plot->p3;
+        }
 
-                        if (lcolor != last_color) {
-                                last_color = lcolor;
-                                set_color(ginfo->draw, gc, last_color);
-                        }
+        if (!record && plot->p2)
+                draw_event_label(ginfo, plot->pos,
+                                 plot->p1, plot->p2, ginfo->draw_width, width_16, font);
+}
 
-                        x = draw_plot_line(ginfo, i, ltime, gc);
+static void draw_plots(struct graph_info *ginfo, gint new_width)
+{
+        struct plot_list *list;
+        struct graph_plot *plot;
+        struct record *record;
+        struct plot_hash *hash;
+        gint pid;
+        gint cpu;
+        gint i;
 
-                        /* Figure out if we can show the text for the previous record */
+        /* Initialize plots */
+        for (i = 0; i < ginfo->plots; i++) {
+                plot = ginfo->plot_array[i];
 
-                        p3 = x;
+                if (!plot->gc)
+                        plot->gc = gdk_gc_new(ginfo->draw->window);
+                plot->p1 = 0;
+                plot->p2 = 0;
+                plot->p3 = 0;
+                plot->last_color = -1;
 
-                        /* Make sure p2 will be non-zero the next iteration */
-                        if (!p3)
-                                p3 = 1;
+                gdk_draw_line(ginfo->curr_pixmap, ginfo->draw->style->black_gc,
+                              0, PLOT_LINE(i), new_width, PLOT_LINE(i));
 
-                        /* first record, continue */
-                        if (p2)
-                                p2 = draw_event_label(ginfo, i,
-                                                      p1, p2, p3, width_16, font);
+                trace_graph_plot_start(ginfo, plot, ginfo->view_start_time);
 
-                        p1 = p2;
-                        p2 = p3;
-                }
+                set_color(ginfo->draw, plot->gc, plot->last_color);
         }
 
-        if (box) {
-                if (bcolor != last_color) {
-                        last_color = bcolor;
-                        set_color(ginfo->draw, gc, last_color);
+        /* Shortcut if we don't have any task plots */
+        if (!ginfo->nr_task_hash && !ginfo->all_recs) {
+                for (cpu = 0; cpu < ginfo->cpus; cpu++) {
+                        hash = trace_graph_plot_find_cpu(ginfo, cpu);
+                        if (!hash)
+                                continue;
+
+                        while ((record = tracecmd_read_data(ginfo->handle, cpu))) {
+                                for (list = hash->plots; list; list = list->next)
+                                        draw_plot(ginfo, list->plot, record);
+                                free_record(record);
+                        }
                 }
-
-                draw_plot_box(ginfo, i, bstart, bend, gc);
+                goto out;
         }
 
-        if (line) {
-                if (lcolor != last_color) {
-                        last_color = lcolor;
-                        set_color(ginfo->draw, gc, last_color);
+        while ((record = tracecmd_read_next_data(ginfo->handle, &cpu))) {
+                hash = trace_graph_plot_find_cpu(ginfo, cpu);
+                if (hash) {
+                        for (list = hash->plots; list; list = list->next)
+                                draw_plot(ginfo, list->plot, record);
                 }
-
-                draw_plot_line(ginfo, i, ltime, gc);
+                pid = pevent_data_pid(ginfo->pevent, record);
+                hash = trace_graph_plot_find_task(ginfo, pid);
+                if (hash) {
+                        for (list = hash->plots; list; list = list->next)
+                                draw_plot(ginfo, list->plot, record);
+                }
+                for (list = ginfo->all_recs; list; list = list->next)
+                        draw_plot(ginfo, list->plot, record);
+                free_record(record);
         }
 
-        if (p2)
-                draw_event_label(ginfo, i,
-                                 p1, p2, ginfo->draw_width, width_16, font);
-
-        trace_graph_plot_end(ginfo, plot);
-
-        return;
+out:
+        for (i = 0; i < ginfo->plots; i++) {
+                plot = ginfo->plot_array[i];
+                draw_plot(ginfo, plot, NULL);
+                trace_graph_plot_end(ginfo, plot);
+                gdk_gc_unref(plot->gc);
+                plot->gc = NULL;
+        }
 }
 
 
@@ -1614,8 +1632,6 @@ static void draw_timeline(struct graph_info *ginfo, gint width)
 static void draw_info(struct graph_info *ginfo,
                       gint new_width)
 {
-        gint i;
-
         if (!ginfo->handle)
                 return;
 
@@ -1626,8 +1642,7 @@ static void draw_info(struct graph_info *ginfo,
 
         draw_timeline(ginfo, new_width);
 
-        for (i = 0; i < ginfo->plots; i++)
-                draw_plot(ginfo, i, new_width, ginfo->read_comms);
+        draw_plots(ginfo, new_width);
 
         ginfo->read_comms = FALSE;
 }
diff --git a/trace-graph.h b/trace-graph.h
index f8d582c..1703ba1 100644
--- a/trace-graph.h
+++ b/trace-graph.h
@@ -14,6 +14,16 @@ typedef void (graph_filter_cb)(struct graph_info *ginfo,
 
 struct graph_plot;
 
+struct plot_info {
+        gboolean                line;
+        int                     lcolor;
+        unsigned long long      ltime;
+        gboolean                box;
+        int                     bcolor;
+        unsigned long long      bstart;
+        unsigned long long      bend;
+};
+
 /*
  * match_time:
  *   Return true if a selected time should expose plot.
@@ -25,8 +35,7 @@ struct graph_plot;
  *   to start plotting.
  *
  * plot_event:
- *   This is called by the plotter. Return 1 to plot an event or
- *   0 to stop the plotting.
+ *   This is called by the plotter.
  *   color returns the color that should be printed.
  *   line returns 1 or 0 if a line should be drawn.
  *   ltime returns the time that the line should be drawn at
@@ -36,7 +45,6 @@ struct graph_plot;
  *    bend is the time the box ends at
  *     (bstart and bend are ignored if box is 0)
  *   time is the time of the current event
- *   (box and line can be true and processed even if the func returns 0)
  *
  * end:
  *   called at the end of the plotting in case the plotter needs to
@@ -64,11 +72,8 @@ struct plot_callbacks {
                       unsigned long long time);
         int (*plot_event)(struct graph_info *ginfo,
                           struct graph_plot *plot,
-                          gboolean *line, int *lcolor,
-                          unsigned long long *ltime,
-                          gboolean *box, int *bcolor,
-                          unsigned long long *bstart,
-                          unsigned long long *bend);
+                          struct record *record,
+                          struct plot_info *info);
         void (*end)(struct graph_info *, struct graph_plot *);
         int (*display_last_event)(struct graph_info *ginfo, struct graph_plot *plot,
                                   struct trace_seq *s, unsigned long long time);
@@ -85,6 +90,11 @@ struct graph_plot {
         char                            *label;
         const struct plot_callbacks     *cb;
         void                            *private;
+
+        /* Used for drawing */
+        gint                             last_color;
+        gint                            p1, p2, p3;
+        GdkGC                           *gc;
 };
 
 struct graph_callbacks {
@@ -117,6 +127,7 @@ struct graph_info {
         gint                    nr_task_hash;
         struct plot_hash        *task_hash[PLOT_HASH_SIZE];
         struct plot_hash        *cpu_hash[PLOT_HASH_SIZE];
+        struct plot_list        *all_recs;
 
         GtkWidget               *widget;        /* Box to hold graph */
         GtkWidget               *scrollwin;     /* graph scroll window */
@@ -263,6 +274,10 @@ void trace_graph_plot_add_cpu(struct graph_info *ginfo, struct graph_plot *plot,
                               gint cpu);
 void trace_graph_plot_remove_cpu(struct graph_info *ginfo, struct graph_plot *plot,
                                  gint cpu);
+void trace_graph_plot_add_all_recs(struct graph_info *ginfo,
+                                   struct graph_plot *plot);
+void trace_graph_plot_remove_all_recs(struct graph_info *ginfo,
+                                      struct graph_plot *plot);
 
 /* plot callbacks */
 int trace_graph_plot_match_time(struct graph_info *ginfo,
@@ -280,11 +295,8 @@ void trace_graph_plot_start(struct graph_info *ginfo,
 
 int trace_graph_plot_event(struct graph_info *ginfo,
                            struct graph_plot *plot,
-                           gboolean *line, int *lcolor,
-                           unsigned long long *ltime,
-                           gboolean *box, int *bcolor,
-                           unsigned long long *bstart,
-                           unsigned long long *bend);
+                           struct record *record,
+                           struct plot_info *info);
 
 void trace_graph_plot_end(struct graph_info *ginfo,
                           struct graph_plot *plot);
diff --git a/trace-plot-cpu.c b/trace-plot-cpu.c
index 2690155..ccc2bff 100644
--- a/trace-plot-cpu.c
+++ b/trace-plot-cpu.c
@@ -204,14 +204,10 @@ static void cpu_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
 
 static int cpu_plot_event(struct graph_info *ginfo,
                           struct graph_plot *plot,
-                          gboolean *line, int *lcolor,
-                          unsigned long long *ltime,
-                          gboolean *box, int *bcolor,
-                          unsigned long long *bstart,
-                          unsigned long long *bend)
+                          struct record *record,
+                          struct plot_info *info)
 {
         struct cpu_plot_info *cpu_info = plot->private;
-        struct record *record;
         int sched_pid;
         int orig_pid;
         int is_sched_switch;
@@ -222,14 +218,13 @@ static int cpu_plot_event(struct graph_info *ginfo,
         int ret = 1;
 
         cpu = cpu_info->cpu;
-        record = tracecmd_read_data(ginfo->handle, cpu);
 
         if (!record) {
                 /* Finish a box if the last record was not idle */
                 if (cpu_info->last_pid > 0) {
-                        *box = TRUE;
-                        *bstart = cpu_info->last_time;
-                        *bend = ginfo->view_end_time;
+                        info->box = TRUE;
+                        info->bstart = cpu_info->last_time;
+                        info->bend = ginfo->view_end_time;
                 }
                 return 0;
         }
@@ -255,19 +250,19 @@ static int cpu_plot_event(struct graph_info *ginfo,
                 box_filter = trace_graph_filter_on_task(ginfo, orig_pid);
 
                 if (!box_filter && cpu_info->last_pid) {
-                        *bcolor = hash_pid(cpu_info->last_pid);
-                        *box = TRUE;
-                        *bstart = cpu_info->last_time;
-                        *bend = record->ts;
+                        info->bcolor = hash_pid(cpu_info->last_pid);
+                        info->box = TRUE;
+                        info->bstart = cpu_info->last_time;
+                        info->bend = record->ts;
                 }
 
                 cpu_info->last_time = record->ts;
         }
 
         if (!filter && !trace_graph_filter_on_event(ginfo, record)) {
-                *line = TRUE;
-                *ltime = record->ts;
-                *lcolor = hash_pid(pid);
+                info->line = TRUE;
+                info->ltime = record->ts;
+                info->lcolor = hash_pid(pid);
         }
 
         cpu_info->last_pid = pid;
@@ -275,8 +270,6 @@ static int cpu_plot_event(struct graph_info *ginfo,
         if (record->ts > ginfo->view_end_time)
                 ret = 0;
 
-        free_record(record);
-
         return ret;
 }
 
diff --git a/trace-plot-task.c b/trace-plot-task.c
index 6b35586..45a0a32 100644
--- a/trace-plot-task.c
+++ b/trace-plot-task.c
@@ -256,16 +256,11 @@ static void task_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
 
 static int task_plot_event(struct graph_info *ginfo,
                            struct graph_plot *plot,
-                           gboolean *line, int *lcolor,
-                           unsigned long long *ltime,
-                           gboolean *box, int *bcolor,
-                           unsigned long long *bstart,
-                           unsigned long long *bend)
+                           struct record *record,
+                           struct plot_info *info)
 {
         struct task_plot_info *task_info = plot->private;
-        struct record *record = NULL;
         gboolean match;
-        int next_cpu;
         int sched_pid;
         int rec_pid;
         int is_wakeup;
@@ -274,91 +269,83 @@ static int task_plot_event(struct graph_info *ginfo,
 
         pid = task_info->pid;
 
-        do {
-                free_record(record);
-
-                record = tracecmd_read_next_data(ginfo->handle, &next_cpu);
-
-                if (!record) {
-                        /* no more records, finish a box if one was started */
-                        if (task_info->last_cpu >= 0) {
-                                *box = TRUE;
-                                *bstart = task_info->last_time;
-                                *bend = ginfo->view_end_time;
-                                *bcolor = hash_cpu(task_info->last_cpu);
-                        }
-                        return 0;
+        if (!record) {
+                /* no more records, finish a box if one was started */
+                if (task_info->last_cpu >= 0) {
+                        info->box = TRUE;
+                        info->bstart = task_info->last_time;
+                        info->bend = ginfo->view_end_time;
+                        info->bcolor = hash_cpu(task_info->last_cpu);
                 }
+                return 0;
+        }
 
-                match = record_matches_pid(ginfo, record, pid, &rec_pid,
-                                           &sched_pid, &is_sched, &is_wakeup);
+        match = record_matches_pid(ginfo, record, pid, &rec_pid,
+                                   &sched_pid, &is_sched, &is_wakeup);
 
-        } while (!match && next_cpu != task_info->last_cpu);
+        if (!match && record->cpu != task_info->last_cpu)
+                return 0;
 
         if (match) {
-                *line = TRUE;
-                *lcolor = hash_pid(rec_pid);
-                *ltime = record->ts;
+                info->line = TRUE;
+                info->lcolor = hash_pid(rec_pid);
+                info->ltime = record->ts;
 
                 if (is_wakeup) {
                         /* Wake up but not task */
-                        *ltime = hash_pid(rec_pid);
-                        free_record(record);
+                        info->ltime = hash_pid(rec_pid);
 
                         /* Another task ? */
-                        if (task_info->last_cpu == next_cpu) {
-                                *box = TRUE;
-                                *bcolor = hash_cpu(task_info->last_cpu);
-                                *bstart = task_info->last_time;
-                                *bend = record->ts;
+                        if (task_info->last_cpu == record->cpu) {
+                                info->box = TRUE;
+                                info->bcolor = hash_cpu(task_info->last_cpu);
+                                info->bstart = task_info->last_time;
+                                info->bend = record->ts;
                                 task_info->last_cpu = -1;
                         }
 
                         return 1;
                 }
 
-                if (task_info->last_cpu != next_cpu) {
+                if (task_info->last_cpu != record->cpu) {
                         if (task_info->last_cpu >= 0) {
                                 /* Switched CPUs */
-                                *box = TRUE;
-                                *bcolor = hash_cpu(task_info->last_cpu);
-                                *bstart = task_info->last_time;
-                                *bend = record->ts;
+                                info->box = TRUE;
+                                info->bcolor = hash_cpu(task_info->last_cpu);
+                                info->bstart = task_info->last_time;
+                                info->bend = record->ts;
                         }
                         task_info->last_time = record->ts;
                 }
 
-                task_info->last_cpu = next_cpu;
+                task_info->last_cpu = record->cpu;
                 if (is_sched) {
                         if (rec_pid != pid) {
                                 /* Just got scheduled in */
-                                task_info->last_cpu = next_cpu;
+                                task_info->last_cpu = record->cpu;
                                 task_info->last_time = record->ts;
-                        } else if (!*box) {
+                        } else if (!info->box) {
                                 /* just got scheduled out */
-                                *box = TRUE;
-                                *bcolor = hash_cpu(task_info->last_cpu);
-                                *bstart = task_info->last_time;
-                                *bend = record->ts;
+                                info->box = TRUE;
+                                info->bcolor = hash_cpu(task_info->last_cpu);
+                                info->bstart = task_info->last_time;
+                                info->bend = record->ts;
                                 task_info->last_cpu = -1;
                         }
                 }
 
-                free_record(record);
                 return 1;
         }
 
         /* not a match, and on the last CPU, scheduled out? */
         if (task_info->last_cpu >= 0) {
-                *box = TRUE;
-                *bcolor = hash_cpu(task_info->last_cpu);
-                *bstart = task_info->last_time;
-                *bend = record->ts;
+                info->box = TRUE;
+                info->bcolor = hash_cpu(task_info->last_cpu);
+                info->bstart = task_info->last_time;
+                info->bend = record->ts;
                 task_info->last_cpu = -1;
         }
 
-        free_record(record);
-
         return 1;
 }
 
@@ -536,7 +523,7 @@ void task_plot_destroy(struct graph_info *ginfo, struct graph_plot *plot)
 {
         struct task_plot_info *task_info = plot->private;
 
-        trace_graph_plot_remove_task(ginfo, plot, task_info->pid);
+        trace_graph_plot_remove_all_recs(ginfo, plot);
 
         free(task_info);
 }
@@ -587,5 +574,5 @@ void graph_plot_task(struct graph_info *ginfo, int pid)
         snprintf(label, 100, "TASK %d", pid);
         plot = trace_graph_plot_append(ginfo, label, &task_plot_cb, task_info);
 
-        trace_graph_plot_add_task(ginfo, plot, pid);
+        trace_graph_plot_add_all_recs(ginfo, plot);
 }
diff --git a/trace-plot.c b/trace-plot.c
index 5ba2ec1..ec76d52 100644
--- a/trace-plot.c
+++ b/trace-plot.c
@@ -262,6 +262,35 @@ void trace_graph_plot_remove_cpu(struct graph_info *ginfo,
         remove_hash(ginfo->cpu_hash, plot, cpu);
 }
 
+void trace_graph_plot_add_all_recs(struct graph_info *ginfo,
+                                   struct graph_plot *plot)
+{
+        struct plot_list *list;
+
+        list = malloc_or_die(sizeof(*list));
+        list->next = ginfo->all_recs;
+        list->plot = plot;
+
+        ginfo->all_recs = list;
+}
+
+void trace_graph_plot_remove_all_recs(struct graph_info *ginfo,
+                                      struct graph_plot *plot)
+{
+        struct plot_list **pplot;
+        struct plot_list *list;
+
+        pplot = &ginfo->all_recs;
+
+        while ((list = *pplot)) {
+                if (list->plot == plot) {
+                        *pplot = list->next;
+                        free(list);
+                        break;
+                }
+                pplot = &list->next;
+        }
+}
 
 /* Plot callback helpers */
 
@@ -287,20 +316,16 @@ void trace_graph_plot_start(struct graph_info *ginfo,
 
 int trace_graph_plot_event(struct graph_info *ginfo,
                            struct graph_plot *plot,
-                           gboolean *line, int *lcolor,
-                           unsigned long long *ltime,
-                           gboolean *box, int *bcolor,
-                           unsigned long long *bstart,
-                           unsigned long long *bend)
+                           struct record *record,
+                           struct plot_info *info)
 {
-        *line = FALSE;
-        *box = FALSE;
+        info->line = FALSE;
+        info->box = FALSE;
 
         if (!plot->cb->plot_event)
                 return 0;
 
-        return plot->cb->plot_event(ginfo, plot, line, lcolor, ltime,
-                                    box, bcolor, bstart, bend);
+        return plot->cb->plot_event(ginfo, plot, record, info);
 }
 
 void trace_graph_plot_end(struct graph_info *ginfo,