trace-graph: Fix plots to show start bars in zoomed views.

Currently, if a zoomed view has events before the start of the view,
those events are not examined to determine if the bar of a graph should
be shown at the start.

This patch adds code to the cpu and task plots to look for events
that happened before the view to determine if a bar should be shown
or not.

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

2 files changed, 143 insertions, 15 deletions

diff --git a/trace-plot-cpu.c b/trace-plot-cpu.c
index 09b1690..d6800ef 100644
--- a/trace-plot-cpu.c
+++ b/trace-plot-cpu.c
@@ -27,6 +27,7 @@ struct cpu_plot_info {
         int                     cpu;
         unsigned long long      last_time;
         int                     last_pid;
+        struct record           *last_record;
 };
 
 static gint hash_pid(gint val)
@@ -192,6 +193,7 @@ static void cpu_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
         cpu = cpu_info->cpu;
         cpu_info->last_time = 0ULL;
         cpu_info->last_pid = -1;
+        cpu_info->last_record = NULL;
 }
 
 static int cpu_plot_event(struct graph_info *ginfo,
@@ -200,6 +202,7 @@ static int cpu_plot_event(struct graph_info *ginfo,
                           struct plot_info *info)
 {
         struct cpu_plot_info *cpu_info = plot->private;
+        struct tracecmd_input *handle = ginfo->handle;
         int sched_pid;
         int orig_pid;
         int is_sched_switch;
@@ -212,6 +215,11 @@ static int cpu_plot_event(struct graph_info *ginfo,
         cpu = cpu_info->cpu;
 
         if (!record) {
+                if (cpu_info->last_record) {
+                        free_record(cpu_info->last_record);
+                        cpu_info->last_record = NULL;
+                }
+
                 /* Finish a box if the last record was not idle */
                 if (cpu_info->last_pid > 0) {
                         info->box = TRUE;
@@ -222,6 +230,30 @@ static int cpu_plot_event(struct graph_info *ginfo,
                 return 0;
         }
 
+        /*
+         * If last record is NULL, then it may exist off the
+         * viewable range. Search to see if one exists.
+         */
+        if (!cpu_info->last_record) {
+                struct record *trecord;
+
+                trecord = tracecmd_read_prev(handle, record);
+                if (trecord) {
+                        filter = filter_record(ginfo, trecord,
+                                               &orig_pid, &sched_pid,
+                                               &is_sched_switch);
+                        cpu_info->last_pid = is_sched_switch ? sched_pid : orig_pid;
+                }
+                cpu_info->last_record = trecord;
+                /* We moved the cursor, put it back */
+                trecord = tracecmd_read_data(handle, record->cpu);
+                free_record(trecord);
+        }
+
+        free_record(cpu_info->last_record);
+        cpu_info->last_record = record;
+        tracecmd_record_ref(record);
+
         cpu = cpu_info->cpu;
 
         filter = filter_record(ginfo, record, &orig_pid, &sched_pid, &is_sched_switch);
diff --git a/trace-plot-task.c b/trace-plot-task.c
index c8d0905..aac771e 100644
--- a/trace-plot-task.c
+++ b/trace-plot-task.c
@@ -29,6 +29,7 @@
 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;
@@ -104,26 +105,31 @@ static gboolean record_matches_pid(struct graph_info *ginfo,
         return FALSE;
 }
 
-static void set_cpus_to_time(struct graph_info *ginfo, unsigned long long time)
+static void set_cpu_to_time(int cpu, struct graph_info *ginfo, unsigned long long time)
 {
         struct record *record;
-        int cpu;
 
-        for (cpu = 0; cpu < ginfo->cpus; cpu++) {
-                tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, time);
+        tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, time);
 
-                while ((record = tracecmd_read_data(ginfo->handle, cpu))) {
-                        if (record->ts >= time)
-                                break;
+        while ((record = tracecmd_read_data(ginfo->handle, cpu))) {
+                if (record->ts >= 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, time);
+                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, time);
+}
+
+static 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 int task_plot_match_time(struct graph_info *ginfo, struct graph_plot *plot,
@@ -315,6 +321,8 @@ static void task_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
 {
         struct task_plot_info *task_info = plot->private;
 
+        memset(task_info->last_records, 0, sizeof(struct record *) * ginfo->cpus);
+
         task_info->last_time = 0ULL;
         task_info->last_cpu = -1;
         task_info->wake_time = 0ULL;
@@ -327,16 +335,22 @@ static int task_plot_event(struct graph_info *ginfo,
                            struct plot_info *info)
 {
         struct task_plot_info *task_info = plot->private;
+        struct tracecmd_input *handle = ginfo->handle;
         gboolean match;
         int sched_pid;
         int rec_pid;
         int is_wakeup;
         int is_sched;
         int pid;
+        int cpu;
 
         pid = task_info->pid;
 
         if (!record) {
+                for (cpu = 0; cpu < ginfo->cpus; cpu++) {
+                        free_record(task_info->last_records[cpu]);
+                        task_info->last_records[cpu] = NULL;
+                }
                 /* no more records, finish a box if one was started */
                 if (task_info->last_cpu >= 0) {
                         info->box = TRUE;
@@ -350,14 +364,85 @@ static int task_plot_event(struct graph_info *ginfo,
         match = record_matches_pid(ginfo, record, pid, &rec_pid,
                                    &sched_pid, &is_sched, &is_wakeup);
 
-        if (!match && record->cpu != task_info->last_cpu)
+
+        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) {
                 info->line = TRUE;
                 info->lcolor = hash_pid(rec_pid);
                 info->ltime = record->ts;
 
+                /*
+                 * Is this our first match?
+                 *
+                 * If last record is NULL, then it may exist off the
+                 * viewable range. Search to see if one exists, and if
+                 * it is the record we want to match.
+                 */
+                for (cpu = 0; cpu < ginfo->cpus; cpu++) {
+                        struct record *trecord, *t2record;
+                        struct record *saved;
+                        int this_cpu = record->cpu;
+                        int tsched_pid;
+                        int tpid;
+                        int tis_wakeup;
+                        int tis_sched;
+
+                        if (task_info->last_records[cpu])
+                                continue;
+
+                        if (cpu == this_cpu) {
+                                static int once;
+
+                                trecord = tracecmd_read_prev(handle, record);
+                                /* Set cpu cursor back to what it was  */
+                                saved = tracecmd_read_data(handle, cpu);
+                                if (!once && saved->offset != record->offset) {
+                                        once++;
+                                        warning("failed to reset cursor!");
+                                }
+                                free_record(saved);
+                        } else {
+                                static int once;
+
+                                saved = tracecmd_peek_data(handle, cpu);
+                                set_cpu_to_time(cpu, ginfo, record->ts);
+                                t2record = tracecmd_read_data(handle, cpu);
+                                trecord = tracecmd_read_prev(handle, t2record);
+                                free_record(t2record);
+                                /* reset cursor back to what it was */
+                                if (saved)
+                                        tracecmd_set_cursor(handle, cpu, saved->offset);
+                                else {
+                                        saved = tracecmd_read_data(handle, cpu);
+                                        if (!once && saved) {
+                                                once++;
+                                                warning("failed to reset cursor to end!");
+                                        }
+                                }
+                        }
+                        if (!trecord)
+                                continue;
+
+                        if (record_matches_pid(ginfo, trecord, pid, &tpid,
+                                               &tsched_pid, &tis_sched, &tis_wakeup) &&
+                            !tis_wakeup &&
+                            (!is_sched || (is_sched && sched_pid == pid))) {
+                                task_info->last_records[cpu] = trecord;
+                                task_info->last_cpu = trecord->cpu;
+                                task_info->last_time = trecord->ts;
+                                break;
+                        }
+
+                        free_record(trecord);
+                }
+
                 if (is_wakeup) {
                         /* Wake up but not task */
                         info->ltime = hash_pid(rec_pid);
@@ -424,6 +509,12 @@ static int task_plot_event(struct graph_info *ginfo,
                 return 1;
         }
 
+        cpu = record->cpu;
+
+        if (!task_info->last_records[cpu]) {
+                free_record(task_info->last_records[cpu]);
+                task_info->last_records[cpu] = record;
+        }
         /* not a match, and on the last CPU, scheduled out? */
         if (task_info->last_cpu >= 0) {
                 info->box = TRUE;
@@ -622,6 +713,7 @@ void task_plot_destroy(struct graph_info *ginfo, struct graph_plot *plot)
 
         trace_graph_plot_remove_all_recs(ginfo, plot);
 
+        free(task_info->last_records);
         free(task_info);
 }
 
@@ -740,6 +832,8 @@ void graph_plot_init_tasks(struct graph_info *ginfo)
         }
 
         task_info = malloc_or_die(sizeof(*task_info));
+        task_info->last_records =
+                malloc_or_die(sizeof(struct record *) * ginfo->cpus);
         task_info->pid = pid;
 
         snprintf(label, 100, "TASK %d", pid);
@@ -756,6 +850,8 @@ 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;
         comm = pevent_data_comm_from_pid(ginfo->pevent, pid);