trace-graph: Added CPU plotting menu

Added menu for adding and removing CPU plots and Tasks.

Only CPU updates have been implemented in this change set.
Task updates will follow.

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

7 files changed, 248 insertions, 17 deletions

diff --git a/cpu.h b/cpu.h
index dabf870..203d79a 100644
--- a/cpu.h
+++ b/cpu.h
@@ -57,4 +57,38 @@ static inline void set_cpus(guint64 *cpu_mask, gint cpus)
         *(cpu_mask) = (1ULL << (cpus & ((1ULL << 6) - 1))) - 1;
 }
 
+static inline gboolean cpus_equal(guint64 *a_mask, guint64 *b_mask,
+                                  gint cpus)
+{
+        gint idx;
+
+        for (idx = 0; idx < (cpus >> 6) + 1; idx++) {
+                if (*(a_mask + idx) != *(b_mask + idx))
+                        return FALSE;
+        }
+        return TRUE;
+}
+
+/* Hamming weight */
+static inline guint hweight(guint mask)
+{
+        guint64 w = mask;
+
+        w -= (w >> 1) & 0x5555555555555555ul;
+        w =  (w & 0x3333333333333333ul) + ((w >> 2) & 0x3333333333333333ul);
+        w =  (w + (w >> 4)) & 0x0f0f0f0f0f0f0f0ful;
+        return (w * 0x0101010101010101ul) >> 56;
+}
+
+static inline guint cpu_weight(guint64 *cpu_mask, guint cpus)
+{
+        guint weight = 0;
+        gint idx;
+
+        for (idx = 0; idx < (cpus >> 6) + 1; idx++)
+                weight += hweight(*(cpu_mask + idx));
+
+        return weight;
+}
+
 #endif /* _CPU_H */
diff --git a/trace-graph-main.c b/trace-graph-main.c
index 987a80d..adc05ca 100644
--- a/trace-graph-main.c
+++ b/trace-graph-main.c
@@ -120,6 +120,37 @@ adv_filter_clicked (gpointer data)
                                 trace_graph_adv_filter_callback, ginfo);
 }
 
+/* Callback for the clicked signal of the plot CPUs button */
+static void
+plot_cpu_clicked (gpointer data)
+{
+        struct graph_info *ginfo = data;
+        gboolean all_cpus;
+        guint64 *cpu_mask;
+
+        if (!ginfo->handle)
+                return;
+
+        graph_plot_cpus_plotted(ginfo, &all_cpus, &cpu_mask);
+
+        trace_filter_cpu_dialog(all_cpus, cpu_mask, ginfo->cpus,
+                                graph_plot_cpus_update_callback, ginfo);
+        g_free(cpu_mask);
+}
+
+/* Callback for the clicked signal of the plot tasks button */
+static void
+plot_tasks_clicked (gpointer data)
+{
+        struct graph_info *ginfo = data;
+        gboolean all_events = TRUE;
+
+        if (!ginfo->handle)
+                return;
+
+        all_events = ginfo->all_events;
+}
+
 void trace_graph(int argc, char **argv)
 {
         struct tracecmd_input *handle = NULL;
@@ -276,6 +307,52 @@ void trace_graph(int argc, char **argv)
         gtk_menu_item_set_submenu(GTK_MENU_ITEM (menu_item), menu);
 
 
+        /* --- Plot Option --- */
+
+        menu_item = gtk_menu_item_new_with_label("Plots");
+        gtk_widget_show(menu_item);
+
+        gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), menu_item);
+
+        menu = gtk_menu_new();    /* Don't need to show menus */
+
+
+        /* --- Plot - CPUs Option --- */
+
+        sub_item = gtk_menu_item_new_with_label("CPUs");
+
+        /* Add them to the menu */
+        gtk_menu_shell_append(GTK_MENU_SHELL (menu), sub_item);
+
+        /* We can attach the Quit menu item to our exit function */
+        g_signal_connect_swapped (G_OBJECT (sub_item), "activate",
+                                  G_CALLBACK (plot_cpu_clicked),
+                                  (gpointer) ginfo);
+
+        /* We do need to show menu items */
+        gtk_widget_show(sub_item);
+
+
+        /* --- Plot - Tasks Option --- */
+
+        sub_item = gtk_menu_item_new_with_label("Tasks");
+
+        /* Add them to the menu */
+        gtk_menu_shell_append(GTK_MENU_SHELL (menu), sub_item);
+
+        /* We can attach the Quit menu item to our exit function */
+        g_signal_connect_swapped (G_OBJECT (sub_item), "activate",
+                                  G_CALLBACK (plot_tasks_clicked),
+                                  (gpointer) ginfo);
+
+        /* We do need to show menu items */
+        gtk_widget_show(sub_item);
+
+
+        /* --- End Plot Options --- */
+        gtk_menu_item_set_submenu(GTK_MENU_ITEM (menu_item), menu);
+
+
         /* --- Top Level Hbox --- */
 
         hbox = gtk_hbox_new(FALSE, 0);
diff --git a/trace-graph.c b/trace-graph.c
index fa76874..3c3f98d 100644
--- a/trace-graph.c
+++ b/trace-graph.c
@@ -2076,6 +2076,12 @@ static int load_handle(struct graph_info *ginfo,
         return 0;
 }
 
+void trace_graph_refresh(struct graph_info *ginfo)
+{
+        update_label_window(ginfo);
+        redraw_graph(ginfo);
+}
+
 int trace_graph_load_handle(struct graph_info *ginfo,
                             struct tracecmd_input *handle)
 {
diff --git a/trace-graph.h b/trace-graph.h
index ae5f50d..7fdc5f0 100644
--- a/trace-graph.h
+++ b/trace-graph.h
@@ -32,6 +32,13 @@ typedef void (graph_filter_cb)(struct graph_info *ginfo,
                                struct filter_task *task_filter,
                                struct filter_task *hide_tasks);
 
+/* Used for quereing what plots are defined */
+enum graph_plot_type {
+        PLOT_TYPE_OTHER,
+        PLOT_TYPE_CPU,
+        PLOT_TYPE_TASK,
+};
+
 struct graph_plot;
 
 struct plot_info {
@@ -108,6 +115,7 @@ struct plot_callbacks {
 };
 
 struct graph_plot {
+        enum graph_plot_type            type;
         int                             pos;
         char                            *label;
         const struct plot_callbacks     *cb;
@@ -251,6 +259,8 @@ static inline GtkWidget *trace_graph_get_window(struct graph_info *ginfo)
         return ginfo->widget;
 }
 
+void trace_graph_refresh(struct graph_info *ginfo);
+
 struct filter_task_item *
 trace_graph_filter_task_find_pid(struct graph_info *ginfo, gint pid);
 struct filter_task_item *
@@ -283,11 +293,13 @@ void trace_graph_plot_free(struct graph_info *ginfo);
 void trace_graph_plot_init(struct graph_info *ginfo);
 struct graph_plot *trace_graph_plot_append(struct graph_info *ginfo,
                                            const char *label,
+                                           enum graph_plot_type type,
                                            const struct plot_callbacks *cb,
                                            void *data);
 struct graph_plot *trace_graph_plot_insert(struct graph_info *ginfo,
                                            int pos,
                                            const char *label,
+                                           enum graph_plot_type type,
                                            const struct plot_callbacks *cb,
                                            void *data);
 void trace_graph_plot_remove(struct graph_info *ginfo, struct graph_plot *plot);
@@ -341,6 +353,12 @@ int trace_graph_plot_display_info(struct graph_info *ginfo,
 
 /* cpu plot */
 void graph_plot_init_cpus(struct graph_info *ginfo, int cpus);
+void graph_plot_cpus_plotted(struct graph_info *ginfo,
+                             gboolean *all_cpus, guint64 **cpu_mask);
+void graph_plot_cpus_update_callback(gboolean accept,
+                                     gboolean all_cpus,
+                                     guint64 *selected_cpu_mask,
+                                     gpointer data);
 
 /* task plot */
 void graph_plot_task(struct graph_info *ginfo, int pid, int pos);
diff --git a/trace-plot-cpu.c b/trace-plot-cpu.c
index e591f04..e99fec8 100644
--- a/trace-plot-cpu.c
+++ b/trace-plot-cpu.c
@@ -21,6 +21,7 @@
 #include <string.h>
 
 #include "trace-graph.h"
+#include "cpu.h"
 
 struct cpu_plot_info {
         int                     cpu;
@@ -385,7 +386,7 @@ int cpu_plot_display_info(struct graph_info *ginfo,
         return 1;
 }
 
-void cpu_plot_destroy(struct graph_info *ginfo, struct graph_plot *plot)
+static void cpu_plot_destroy(struct graph_info *ginfo, struct graph_plot *plot)
 {
         struct cpu_plot_info *cpu_info = plot->private;
 
@@ -403,20 +404,112 @@ static const struct plot_callbacks cpu_plot_cb = {
         .destroy                = cpu_plot_destroy
 };
 
-void graph_plot_init_cpus(struct graph_info *ginfo, int cpus)
+static void add_cpu_plot(struct graph_info *ginfo, gint cpu)
 {
         struct cpu_plot_info *cpu_info;
         struct graph_plot *plot;
         char label[100];
-        long cpu;
 
-        for (cpu = 0; cpu < cpus; cpu++) {
-                cpu_info = malloc_or_die(sizeof(*cpu_info));
-                cpu_info->cpu = cpu;
+        cpu_info = malloc_or_die(sizeof(*cpu_info));
+        cpu_info->cpu = cpu;
+
+        snprintf(label, 100, "CPU %d", cpu);
+
+        plot = trace_graph_plot_append(ginfo, label, PLOT_TYPE_CPU,
+                                       &cpu_plot_cb, cpu_info);
+        trace_graph_plot_add_cpu(ginfo, plot, cpu);
+}
+
+void graph_plot_cpus_update_callback(gboolean accept,
+                                     gboolean all_cpus,
+                                     guint64 *selected_cpu_mask,
+                                     gpointer data)
+{
+        struct graph_info *ginfo = data;
+        struct cpu_plot_info *cpu_info;
+        struct graph_plot *plot;
+        gboolean old_all_cpus;
+        guint64 *old_cpu_mask;
+        int i;
+
+        if (!accept)
+                return;
+
+        /* Get the current status */
+        graph_plot_cpus_plotted(ginfo, &old_all_cpus, &old_cpu_mask);
+
+        if (old_all_cpus == all_cpus ||
+            (selected_cpu_mask &&
+             cpus_equal(old_cpu_mask, selected_cpu_mask, ginfo->cpus))) {
+                /* Nothing to do */
+                g_free(old_cpu_mask);
+                return;
+        }
 
-                snprintf(label, 100, "CPU %ld", cpu);
+        if (!all_cpus) {
+                /*
+                 * Remove any plots not selected.
+                 * Go backwards, since removing a plot shifts the
+                 * array from current position back.
+                 */
+                for (i = ginfo->plots - 1; i >= 0; i--) {
+                        plot = ginfo->plot_array[i];
+                        if (plot->type != PLOT_TYPE_CPU)
+                                continue;
+                        cpu_info = plot->private;
+                        if (!cpu_isset(selected_cpu_mask, cpu_info->cpu))
+                                trace_graph_plot_remove(ginfo, plot);
+                }
+        }
 
-                plot = trace_graph_plot_append(ginfo, label, &cpu_plot_cb, cpu_info);
-                trace_graph_plot_add_cpu(ginfo, plot, cpu);
+        /* Now add any plots not set */
+        for (i = 0; i < ginfo->cpus; i++) {
+                if (!all_cpus && !cpu_isset(selected_cpu_mask, i))
+                        continue;
+                if (cpu_isset(old_cpu_mask, i))
+                        continue;
+                add_cpu_plot(ginfo, i);
         }
+
+        g_free(old_cpu_mask);
+
+        trace_graph_refresh(ginfo);
+}
+
+/**
+ * graph_plot_cpus_plotted - return what CPUs are plotted
+ * @ginfo: the graph info structure
+ * @all_cpus: returns true if all CPUS are currently plotted
+ * @cpu_mask: returns an allocated mask of what cpus are set
+ *
+ * @cpu_mask must be freed with g_free() after this is called.
+ */
+void graph_plot_cpus_plotted(struct graph_info *ginfo,
+                             gboolean *all_cpus, guint64 **cpu_mask)
+{
+        struct cpu_plot_info *cpu_info;
+        struct graph_plot *plot;
+        int i;
+
+        *cpu_mask = g_new0(guint64, (ginfo->cpus >> 6) + 1);
+        g_assert(*cpu_mask);
+
+        for (i = 0; i < ginfo->plots; i++) {
+                plot = ginfo->plot_array[i];
+                if (plot->type != PLOT_TYPE_CPU)
+                        continue;
+                cpu_info = plot->private;
+                cpu_set(*cpu_mask, cpu_info->cpu);
+        }
+
+        *all_cpus = cpu_weight(*cpu_mask, ginfo->cpus) == ginfo->cpus ?
+                TRUE : FALSE;
+}
+
+void graph_plot_init_cpus(struct graph_info *ginfo, int cpus)
+{
+        long cpu;
+
+        for (cpu = 0; cpu < cpus; cpu++)
+                add_cpu_plot(ginfo, cpu);
 }
diff --git a/trace-plot-task.c b/trace-plot-task.c
index b36d565..a5b8d79 100644
--- a/trace-plot-task.c
+++ b/trace-plot-task.c
@@ -632,7 +632,8 @@ void graph_plot_init_tasks(struct graph_info *ginfo)
         task_info->pid = pid;
 
         snprintf(label, 100, "TASK %d", pid);
-        trace_graph_plot_insert(ginfo, 1, label, &task_plot_cb, task_info);
+        trace_graph_plot_insert(ginfo, 1, label, PLOT_TYPE_TASK,
+                                &task_plot_cb, task_info);
 }
 
 void graph_plot_task(struct graph_info *ginfo, int pid, int pos)
@@ -650,7 +651,8 @@ void graph_plot_task(struct graph_info *ginfo, int pid, int pos)
         len = strlen(comm) + 100;
         label = malloc_or_die(len);
         snprintf(label, len, "%s-%d", comm, pid);
-        plot = trace_graph_plot_insert(ginfo, pos, label, &task_plot_cb, task_info);
+        plot = trace_graph_plot_insert(ginfo, pos, label, PLOT_TYPE_TASK,
+                                       &task_plot_cb, task_info);
         free(label);
 
         trace_graph_plot_add_all_recs(ginfo, plot);
diff --git a/trace-plot.c b/trace-plot.c
index 8376814..f8e23c0 100644
--- a/trace-plot.c
+++ b/trace-plot.c
@@ -75,13 +75,14 @@ allocate_plot(struct graph_info *ginfo,
 
 struct graph_plot *
 trace_graph_plot_append(struct graph_info *ginfo,
-                        const char *label, const struct plot_callbacks *cb,
-                        void *data)
+                        const char *label, enum graph_plot_type type,
+                        const struct plot_callbacks *cb, void *data)
 {
         struct graph_plot *plot;
 
         plot = allocate_plot(ginfo, label, cb, data);
 
+        plot->type = type;
         plot->pos = ginfo->plots;
 
         if (!ginfo->plots) {
@@ -105,21 +106,21 @@ trace_graph_plot_append(struct graph_info *ginfo,
 
 struct graph_plot *
 trace_graph_plot_insert(struct graph_info *ginfo,
-                        int pos,
-                        const char *label, const struct plot_callbacks *cb,
-                        void *data)
+                        int pos, const char *label, enum graph_plot_type type,
+                        const struct plot_callbacks *cb, void *data)
 {
         struct graph_plot *plot;
         int i;
 
         if (pos >= ginfo->plots)
-                return trace_graph_plot_append(ginfo, label, cb, data);
+                return trace_graph_plot_append(ginfo, label, type, cb, data);
 
         if (pos < 0)
                 pos = 0;
 
         plot = allocate_plot(ginfo, label, cb, data);
         plot->pos = pos;
+        plot->type = type;
         ginfo->plot_array = realloc(ginfo->plot_array,
                                     sizeof(ginfo->plot_array[0]) *
                                     (ginfo->plots + 1));