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_fmt *fmt __maybe_unused, \
  95                                        struct perf_hpp *hpp,                    \
  96                                        struct hist_entry *he)                   \
  97 {                                                                               \
  98         return __hpp__color_fmt(hpp, he, he_get_##_field);                      \
  99 }
 100
 101 __HPP_COLOR_PERCENT_FN(overhead, period)
 102 __HPP_COLOR_PERCENT_FN(overhead_sys, period_sys)
 103 __HPP_COLOR_PERCENT_FN(overhead_us, period_us)
 104 __HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys)
 105 __HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)
 106
 107 #undef __HPP_COLOR_PERCENT_FN
 108
 109
 110 void perf_gtk__init_hpp(void)
 111 {
 112         perf_hpp__init();
 113
 114         perf_hpp__format[PERF_HPP__OVERHEAD].color =
 115                                 perf_gtk__hpp_color_overhead;
 116         perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
 117                                 perf_gtk__hpp_color_overhead_sys;
 118         perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
 119                                 perf_gtk__hpp_color_overhead_us;
 120         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
 121                                 perf_gtk__hpp_color_overhead_guest_sys;
 122         perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
 123                                 perf_gtk__hpp_color_overhead_guest_us;
 124 }
 125
 126 static void callchain_list__sym_name(struct callchain_list *cl,
 127                                      char *bf, size_t bfsize)
 128 {
 129         if (cl->ms.sym)
 130                 scnprintf(bf, bfsize, "%s", cl->ms.sym->name);
 131         else
 132                 scnprintf(bf, bfsize, "%#" PRIx64, cl->ip);
 133 }
 134
 135 static void perf_gtk__add_callchain(struct rb_root *root, GtkTreeStore *store,
 136                                     GtkTreeIter *parent, int col, u64 total)
 137 {
 138         struct rb_node *nd;
 139         bool has_single_node = (rb_first(root) == rb_last(root));
 140
 141         for (nd = rb_first(root); nd; nd = rb_next(nd)) {
 142                 struct callchain_node *node;
 143                 struct callchain_list *chain;
 144                 GtkTreeIter iter, new_parent;
 145                 bool need_new_parent;
 146                 double percent;
 147                 u64 hits, child_total;
 148
 149                 node = rb_entry(nd, struct callchain_node, rb_node);
 150
 151                 hits = callchain_cumul_hits(node);
 152                 percent = 100.0 * hits / total;
 153
 154                 new_parent = *parent;
 155                 need_new_parent = !has_single_node && (node->val_nr > 1);
 156
 157                 list_for_each_entry(chain, &node->val, list) {
 158                         char buf[128];
 159
 160                         gtk_tree_store_append(store, &iter, &new_parent);
 161
 162                         scnprintf(buf, sizeof(buf), "%5.2f%%", percent);
 163                         gtk_tree_store_set(store, &iter, 0, buf, -1);
 164
 165                         callchain_list__sym_name(chain, buf, sizeof(buf));
 166                         gtk_tree_store_set(store, &iter, col, buf, -1);
 167
 168                         if (need_new_parent) {
 169                                 /*
 170                                  * Only show the top-most symbol in a callchain
 171                                  * if it's not the only callchain.
 172                                  */
 173                                 new_parent = iter;
 174                                 need_new_parent = false;
 175                         }
 176                 }
 177
 178                 if (callchain_param.mode == CHAIN_GRAPH_REL)
 179                         child_total = node->children_hit;
 180                 else
 181                         child_total = total;
 182
 183                 /* Now 'iter' contains info of the last callchain_list */
 184                 perf_gtk__add_callchain(&node->rb_root, store, &iter, col,
 185                                         child_total);
 186         }
 187 }
 188
 189 static void on_row_activated(GtkTreeView *view, GtkTreePath *path,
 190                              GtkTreeViewColumn *col __maybe_unused,
 191                              gpointer user_data __maybe_unused)
 192 {
 193         bool expanded = gtk_tree_view_row_expanded(view, path);
 194
 195         if (expanded)
 196                 gtk_tree_view_collapse_row(view, path);
 197         else
 198                 gtk_tree_view_expand_row(view, path, FALSE);
 199 }
 200
 201 static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists,
 202                                  float min_pcnt)
 203 {
 204         struct perf_hpp_fmt *fmt;
 205         GType col_types[MAX_COLUMNS];
 206         GtkCellRenderer *renderer;
 207         struct sort_entry *se;
 208         GtkTreeStore *store;
 209         struct rb_node *nd;
 210         GtkWidget *view;
 211         int col_idx;
 212         int sym_col = -1;
 213         int nr_cols;
 214         char s[512];
 215
 216         struct perf_hpp hpp = {
 217                 .buf            = s,
 218                 .size           = sizeof(s),
 219                 .ptr            = hists_to_evsel(hists),
 220         };
 221
 222         nr_cols = 0;
 223
 224         perf_hpp__for_each_format(fmt)
 225                 col_types[nr_cols++] = G_TYPE_STRING;
 226
 227         list_for_each_entry(se, &hist_entry__sort_list, list) {
 228                 if (se->elide)
 229                         continue;
 230
 231                 if (se == &sort_sym)
 232                         sym_col = nr_cols;
 233
 234                 col_types[nr_cols++] = G_TYPE_STRING;
 235         }
 236
 237         store = gtk_tree_store_newv(nr_cols, col_types);
 238
 239         view = gtk_tree_view_new();
 240
 241         renderer = gtk_cell_renderer_text_new();
 242
 243         col_idx = 0;
 244
 245         perf_hpp__for_each_format(fmt) {
 246                 fmt->header(fmt, &hpp);
 247
 248                 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
 249                                                             -1, ltrim(s),
 250                                                             renderer, "markup",
 251                                                             col_idx++, NULL);
 252         }
 253
 254         list_for_each_entry(se, &hist_entry__sort_list, list) {
 255                 if (se->elide)
 256                         continue;
 257
 258                 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
 259                                                             -1, se->se_header,
 260                                                             renderer, "text",
 261                                                             col_idx++, NULL);
 262         }
 263
 264         for (col_idx = 0; col_idx < nr_cols; col_idx++) {
 265                 GtkTreeViewColumn *column;
 266
 267                 column = gtk_tree_view_get_column(GTK_TREE_VIEW(view), col_idx);
 268                 gtk_tree_view_column_set_resizable(column, TRUE);
 269
 270                 if (col_idx == sym_col) {
 271                         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(view),
 272                                                           column);
 273                 }
 274         }
 275
 276         gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
 277
 278         g_object_unref(GTK_TREE_MODEL(store));
 279
 280         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
 281                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 282                 GtkTreeIter iter;
 283                 float percent = h->stat.period * 100.0 /
 284                                         hists->stats.total_period;
 285
 286                 if (h->filtered)
 287                         continue;
 288
 289                 if (percent < min_pcnt)
 290                         continue;
 291
 292                 gtk_tree_store_append(store, &iter, NULL);
 293
 294                 col_idx = 0;
 295
 296                 perf_hpp__for_each_format(fmt) {
 297                         if (fmt->color)
 298                                 fmt->color(fmt, &hpp, h);
 299                         else
 300                                 fmt->entry(fmt, &hpp, h);
 301
 302                         gtk_tree_store_set(store, &iter, col_idx++, s, -1);
 303                 }
 304
 305                 list_for_each_entry(se, &hist_entry__sort_list, list) {
 306                         if (se->elide)
 307                                 continue;
 308
 309                         se->se_snprintf(h, s, ARRAY_SIZE(s),
 310                                         hists__col_len(hists, se->se_width_idx));
 311
 312                         gtk_tree_store_set(store, &iter, col_idx++, s, -1);
 313                 }
 314
 315                 if (symbol_conf.use_callchain && sort__has_sym) {
 316                         u64 total;
 317
 318                         if (callchain_param.mode == CHAIN_GRAPH_REL)
 319                                 total = h->stat.period;
 320                         else
 321                                 total = hists->stats.total_period;
 322
 323                         perf_gtk__add_callchain(&h->sorted_chain, store, &iter,
 324                                                 sym_col, total);
 325                 }
 326         }
 327
 328         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
 329
 330         g_signal_connect(view, "row-activated",
 331                          G_CALLBACK(on_row_activated), NULL);
 332         gtk_container_add(GTK_CONTAINER(window), view);
 333 }
 334
 335 int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
 336                                   const char *help,
 337                                   struct hist_browser_timer *hbt __maybe_unused,
 338                                   float min_pcnt)
 339 {
 340         struct perf_evsel *pos;
 341         GtkWidget *vbox;
 342         GtkWidget *notebook;
 343         GtkWidget *info_bar;
 344         GtkWidget *statbar;
 345         GtkWidget *window;
 346
 347         signal(SIGSEGV, perf_gtk__signal);
 348         signal(SIGFPE,  perf_gtk__signal);
 349         signal(SIGINT,  perf_gtk__signal);
 350         signal(SIGQUIT, perf_gtk__signal);
 351         signal(SIGTERM, perf_gtk__signal);
 352
 353         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 354
 355         gtk_window_set_title(GTK_WINDOW(window), "perf report");
 356
 357         g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
 358
 359         pgctx = perf_gtk__activate_context(window);
 360         if (!pgctx)
 361                 return -1;
 362
 363         vbox = gtk_vbox_new(FALSE, 0);
 364
 365         notebook = gtk_notebook_new();
 366
 367         gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
 368
 369         info_bar = perf_gtk__setup_info_bar();
 370         if (info_bar)
 371                 gtk_box_pack_start(GTK_BOX(vbox), info_bar, FALSE, FALSE, 0);
 372
 373         statbar = perf_gtk__setup_statusbar();
 374         gtk_box_pack_start(GTK_BOX(vbox), statbar, FALSE, FALSE, 0);
 375
 376         gtk_container_add(GTK_CONTAINER(window), vbox);
 377
 378         evlist__for_each(evlist, pos) {
 379                 struct hists *hists = &pos->hists;
 380                 const char *evname = perf_evsel__name(pos);
 381                 GtkWidget *scrolled_window;
 382                 GtkWidget *tab_label;
 383                 char buf[512];
 384                 size_t size = sizeof(buf);
 385
 386                 if (symbol_conf.event_group) {
 387                         if (!perf_evsel__is_group_leader(pos))
 388                                 continue;
 389
 390                         if (pos->nr_members > 1) {
 391                                 perf_evsel__group_desc(pos, buf, size);
 392                                 evname = buf;
 393                         }
 394                 }
 395
 396                 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
 397
 398                 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
 399                                                         GTK_POLICY_AUTOMATIC,
 400                                                         GTK_POLICY_AUTOMATIC);
 401
 402                 perf_gtk__show_hists(scrolled_window, hists, min_pcnt);
 403
 404                 tab_label = gtk_label_new(evname);
 405
 406                 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
 407         }
 408
 409         gtk_widget_show_all(window);
 410
 411         perf_gtk__resize_window(window);
 412
 413         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 414
 415         ui_helpline__push(help);
 416
 417         gtk_main();
 418
 419         perf_gtk__deactivate_context(&pgctx);
 420
 421         return 0;
 422 }