1 files changed, 142 insertions, 24 deletions

diff --git a/trace-plot-task.c b/trace-plot-task.c
index c8d0905..794b889 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;
@@ -54,7 +55,9 @@ static gint hash_pid(gint val)
 
 static int hash_cpu(int cpu)
 {
-        return trace_hash(cpu + 124);
+        cpu = (cpu << 3) + cpu * 21;
+ 
+        return trace_hash(cpu);
 }
 
 static gboolean is_running(struct graph_info *ginfo, struct record *record)
@@ -104,26 +107,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,12 +323,92 @@ 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;
         task_info->display_wake_time = 0ULL;
 }
 
+static void update_last_record(struct graph_info *ginfo,
+                               struct task_plot_info *task_info,
+                               struct record *record)
+{
+        struct tracecmd_input *handle = ginfo->handle;
+        struct record *trecord, *t2record;
+        struct record *saved;
+        unsigned long long ts;
+        int sched_pid;
+        int pid;
+        int rec_pid;
+        int is_wakeup;
+        int is_sched;
+        int this_cpu;
+        int cpu;
+
+        pid = task_info->pid;
+
+        if (record) {
+                ts = record->ts;
+                this_cpu = record->cpu;
+        } else {
+                ts = ginfo->view_end_time;
+                this_cpu = -1;
+        }
+
+        for (cpu = 0; cpu < ginfo->cpus; cpu++) {
+
+                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, 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, &rec_pid,
+                                       &sched_pid, &is_sched, &is_wakeup) &&
+                    !is_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);
+        }
+}
+
 static int task_plot_event(struct graph_info *ginfo,
                            struct graph_plot *plot,
                            struct record *record,
@@ -333,10 +421,12 @@ static int task_plot_event(struct graph_info *ginfo,
         int is_wakeup;
         int is_sched;
         int pid;
+        int cpu;
 
         pid = task_info->pid;
 
         if (!record) {
+                update_last_record(ginfo, task_info, record);
                 /* no more records, finish a box if one was started */
                 if (task_info->last_cpu >= 0) {
                         info->box = TRUE;
@@ -344,20 +434,39 @@ static int task_plot_event(struct graph_info *ginfo,
                         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;
+                }
                 return 0;
         }
 
         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.
+                 */
+                update_last_record(ginfo, task_info, record);
+
                 if (is_wakeup) {
                         /* Wake up but not task */
                         info->ltime = hash_pid(rec_pid);
@@ -424,6 +533,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;
@@ -571,7 +686,9 @@ int task_plot_display_info(struct graph_info *ginfo,
         struct pevent *pevent;
         unsigned long sec, usec;
         const char *comm;
+        int cpu;
         int type;
+        int sched_pid = -1;
         int pid;
 
         pid = task_info->pid;
@@ -582,7 +699,7 @@ int task_plot_display_info(struct graph_info *ginfo,
         pevent = ginfo->pevent;
 
         pid = pevent_data_pid(ginfo->pevent, record);
-        comm = pevent_data_comm_from_pid(ginfo->pevent, pid);
+        cpu = record->cpu;
 
         convert_nano(record->ts, &sec, &usec);
 
@@ -600,16 +717,12 @@ int task_plot_display_info(struct graph_info *ginfo,
                         trace_seq_putc(s, '\n');
                 } else
                         trace_seq_printf(s, "UNKNOW EVENT %d\n", type);
-        } else {
-                if (record->ts < time)
-                        trace_graph_check_sched_switch(ginfo, record, &pid, &comm);
         }
+        trace_graph_check_sched_switch(ginfo, record, &sched_pid, &comm);
 
         trace_seq_printf(s, "%lu.%06lu", sec, usec);
-        if (pid)
-                trace_seq_printf(s, " %s-%d", comm, pid);
-        else
-                trace_seq_puts(s, " <idle>");
+        if (pid == task_info->pid || sched_pid == task_info->pid)
+                trace_seq_printf(s, " CPU: %03d", cpu);
 
         free_record(record);
 
@@ -622,6 +735,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 +854,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 +872,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);