tools/perf/ui/gtk/hists.c

   1 #include "../evlist.h"
   2 #include "../cache.h"
   3 #include "../evsel.h"
   4 #include "../sort.h"
   5 #include "../hist.h"
   6 #include "../helpline.h"
   7 #include "gtk.h"
   8
   9 #define MAX_COLUMNS                     32
  10
  11 static int __percent_color_snprintf(char *buf, size_t size, double percent)
  12 {
  13         int ret = 0;
  14         const char *markup;
  15
  16         markup = perf_gtk__get_percent_color(percent);
  17         if (markup)
  18                 ret += scnprintf(buf, size, markup);
  19
  20         ret += scnprintf(buf + ret, size - ret, " %6.2f%%", percent);
  21
  22         if (markup)
  23                 ret += scnprintf(buf + ret, size - ret, "</span>");
  24
  25         return ret;
  26 }
  27
  28
  29 static int __hpp__color_fmt(struct perf_hpp *hpp, struct hist_entry *he,
  30                             u64 (*get_field)(struct hist_entry *))
  31 {
  32         int ret;
  33         double percent = 0.0;
  34         struct hists *hists = he->hists;
  35         struct perf_evsel *evsel = hists_to_evsel(hists);
  36
  37         if (hists->stats.total_period)
  38                 percent = 100.0 * get_field(he) / hists->stats.total_period;
  39
  40         ret = __percent_color_snprintf(hpp->buf, hpp->size, percent);
  41
  42         if (perf_evsel__is_group_event(evsel)) {
  43                 int prev_idx, idx_delta;
  44                 struct hist_entry *pair;
  45                 int nr_members = evsel->nr_members;
  46
  47                 prev_idx = perf_evsel__group_idx(evsel);
  48
  49                 list_for_each_entry(pair, &he->pairs.head, pairs.node) {
  50                         u64 period = get_field(pair);
  51                         u64 total = pair->hists->stats.total_period;
  52
  53                         evsel = hists_to_evsel(pair->hists);
  54                         idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;
  55
  56                         while (idx_delta--) {
  57                                 /*
  58                                  * zero-fill group members in the middle which
  59                                  * have no sample
  60                                  */
  61                                 ret += __percent_color_snprintf(hpp->buf + ret,
  62                                                                 hpp->size - ret,
  63                                                                 0.0);
  64                         }
  65
  66                         percent = 100.0 * period / total;
  67                         ret += __percent_color_snprintf(hpp->buf + ret,
  68                                                         hpp->size - ret,
  69                                                         percent);
  70
  71                         prev_idx = perf_evsel__group_idx(evsel);
  72                 }
  73
  74                 idx_delta = nr_members - prev_idx - 1;
  75
  76                 while (idx_delta--) {
  77                         /*
  78                          * zero-fill group members at last which have no sample
  79                          */
  80                         ret += __percent_color_snprintf(hpp->buf + ret,
  81                                                         hpp->size - ret,
  82                                                         0.0);
  83                 }
  84         }
  85         return ret;
  86 }
  87
  88 #define __HPP_COLOR_PERCENT_FN(_type, _field)                                   \
  89 static u64 he_get_##_field(struct hist_entry *he)                               \
  90 {                                                                               \
  91         return he->stat._field;                                                 \
  92 }                                                                               \
  93                                                                                 \
  94 static int perf_gtk__hpp_color_##_type(struct perf_hpp *hpp,                    \
  95                                        struct hist_entry *he)                   \
  96 {                                                                               \
  97         return __hpp__color_fmt(hpp, he, he_get_##_field);                      \
  98 }
  99
 100 __HPP_COLOR_PERCENT_FN(overhead, period)
 101 __HPP_COLOR_PERCENT_FN(overhead_sys, period_sys)
 102 __HPP_COLOR_PERCENT_FN(overhead_us, period_us)
 103 __HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys)
 104 __HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)
 105
 106 #undef __HPP_COLOR_PERCENT_FN
 107
 108
 109 void perf_gtk__init_hpp(void)
 110 {
 111         perf_hpp__column_enable(PERF_HPP__OVERHEAD);
 112
 113         perf_hpp__init();
 114
 115         perf_hpp__format[PERF_HPP__OVERHEAD].color =
 116                                 perf_gtk__hpp_color_overhead;
 117         perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
 118                                 perf_gtk__hpp_color_overhead_sys;
 119         perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
 120                                 perf_gtk__hpp_color_overhead_us;
 121         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
 122                                 perf_gtk__hpp_color_overhead_guest_sys;
 123         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
 124                                 perf_gtk__hpp_color_overhead_guest_us;
 125 }
 126
 127 static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
 128 {
 129         struct perf_hpp_fmt *fmt;
 130         GType col_types[MAX_COLUMNS];
 131         GtkCellRenderer *renderer;
 132         struct sort_entry *se;
 133         GtkListStore *store;
 134         struct rb_node *nd;
 135         GtkWidget *view;
 136         int col_idx;
 137         int nr_cols;
 138         char s[512];
 139
 140         struct perf_hpp hpp = {
 141                 .buf            = s,
 142                 .size           = sizeof(s),
 143                 .ptr            = hists_to_evsel(hists),
 144         };
 145
 146         nr_cols = 0;
 147
 148         perf_hpp__for_each_format(fmt)
 149                 col_types[nr_cols++] = G_TYPE_STRING;
 150
 151         list_for_each_entry(se, &hist_entry__sort_list, list) {
 152                 if (se->elide)
 153                         continue;
 154
 155                 col_types[nr_cols++] = G_TYPE_STRING;
 156         }
 157
 158         store = gtk_list_store_newv(nr_cols, col_types);
 159
 160         view = gtk_tree_view_new();
 161
 162         renderer = gtk_cell_renderer_text_new();
 163
 164         col_idx = 0;
 165
 166         perf_hpp__for_each_format(fmt) {
 167                 fmt->header(&hpp);
 168
 169                 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
 170                                                             -1, ltrim(s),
 171                                                             renderer, "markup",
 172                                                             col_idx++, NULL);
 173         }
 174
 175         list_for_each_entry(se, &hist_entry__sort_list, list) {
 176                 if (se->elide)
 177                         continue;
 178
 179                 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
 180                                                             -1, se->se_header,
 181                                                             renderer, "text",
 182                                                             col_idx++, NULL);
 183         }
 184
 185         gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
 186
 187         g_object_unref(GTK_TREE_MODEL(store));
 188
 189         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
 190                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 191                 GtkTreeIter iter;
 192
 193                 if (h->filtered)
 194                         continue;
 195
 196                 gtk_list_store_append(store, &iter);
 197
 198                 col_idx = 0;
 199
 200                 perf_hpp__for_each_format(fmt) {
 201                         if (fmt->color)
 202                                 fmt->color(&hpp, h);
 203                         else
 204                                 fmt->entry(&hpp, h);
 205
 206                         gtk_list_store_set(store, &iter, col_idx++, s, -1);
 207                 }
 208
 209                 list_for_each_entry(se, &hist_entry__sort_list, list) {
 210                         if (se->elide)
 211                                 continue;
 212
 213                         se->se_snprintf(h, s, ARRAY_SIZE(s),
 214                                         hists__col_len(hists, se->se_width_idx));
 215
 216                         gtk_list_store_set(store, &iter, col_idx++, s, -1);
 217                 }
 218         }
 219
 220         gtk_container_add(GTK_CONTAINER(window), view);
 221 }
 222
 223 int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
 224                                   const char *help,
 225                                   struct hist_browser_timer *hbt __maybe_unused)
 226 {
 227         struct perf_evsel *pos;
 228         GtkWidget *vbox;
 229         GtkWidget *notebook;
 230         GtkWidget *info_bar;
 231         GtkWidget *statbar;
 232         GtkWidget *window;
 233
 234         signal(SIGSEGV, perf_gtk__signal);
 235         signal(SIGFPE,  perf_gtk__signal);
 236         signal(SIGINT,  perf_gtk__signal);
 237         signal(SIGQUIT, perf_gtk__signal);
 238         signal(SIGTERM, perf_gtk__signal);
 239
 240         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 241
 242         gtk_window_set_title(GTK_WINDOW(window), "perf report");
 243
 244         g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
 245
 246         pgctx = perf_gtk__activate_context(window);
 247         if (!pgctx)
 248                 return -1;
 249
 250         vbox = gtk_vbox_new(FALSE, 0);
 251
 252         notebook = gtk_notebook_new();
 253
 254         gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
 255
 256         info_bar = perf_gtk__setup_info_bar();
 257         if (info_bar)
 258                 gtk_box_pack_start(GTK_BOX(vbox), info_bar, FALSE, FALSE, 0);
 259
 260         statbar = perf_gtk__setup_statusbar();
 261         gtk_box_pack_start(GTK_BOX(vbox), statbar, FALSE, FALSE, 0);
 262
 263         gtk_container_add(GTK_CONTAINER(window), vbox);
 264
 265         list_for_each_entry(pos, &evlist->entries, node) {
 266                 struct hists *hists = &pos->hists;
 267                 const char *evname = perf_evsel__name(pos);
 268                 GtkWidget *scrolled_window;
 269                 GtkWidget *tab_label;
 270                 char buf[512];
 271                 size_t size = sizeof(buf);
 272
 273                 if (symbol_conf.event_group) {
 274                         if (!perf_evsel__is_group_leader(pos))
 275                                 continue;
 276
 277                         if (pos->nr_members > 1) {
 278                                 perf_evsel__group_desc(pos, buf, size);
 279                                 evname = buf;
 280                         }
 281                 }
 282
 283                 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
 284
 285                 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
 286                                                         GTK_POLICY_AUTOMATIC,
 287                                                         GTK_POLICY_AUTOMATIC);
 288
 289                 perf_gtk__show_hists(scrolled_window, hists);
 290
 291                 tab_label = gtk_label_new(evname);
 292
 293                 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
 294         }
 295
 296         gtk_widget_show_all(window);
 297
 298         perf_gtk__resize_window(window);
 299
 300         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 301
 302         ui_helpline__push(help);
 303
 304         gtk_main();
 305
 306         perf_gtk__deactivate_context(&pgctx);
 307
 308         return 0;
 309 }