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
__percent_color_snprintf(char * buf,size_t size,double percent)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
__hpp__color_fmt(struct perf_hpp * hpp,struct hist_entry * he,u64 (* get_field)(struct hist_entry *))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
__HPP_COLOR_PERCENT_FN(overhead,period)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
callchain_list__sym_name(struct callchain_list * cl,char * bf,size_t bfsize)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
perf_gtk__add_callchain(struct rb_root * root,GtkTreeStore * store,GtkTreeIter * parent,int col,u64 total)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
on_row_activated(GtkTreeView * view,GtkTreePath * path,GtkTreeViewColumn * col __maybe_unused,gpointer user_data __maybe_unused)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
perf_gtk__show_hists(GtkWidget * window,struct hists * hists,float min_pcnt)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
perf_evlist__gtk_browse_hists(struct perf_evlist * evlist,const char * help,struct hist_browser_timer * hbt __maybe_unused,float min_pcnt)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 list_for_each_entry(pos, &evlist->entries, node) {
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 }
423