Merge tag 'perf-core-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git...
[~shefty/rdma-dev.git] / tools / perf / ui / hist.c
1 #include <math.h>
2
3 #include "../util/hist.h"
4 #include "../util/util.h"
5 #include "../util/sort.h"
6
7
8 /* hist period print (hpp) functions */
9 static int hpp__header_overhead(struct perf_hpp *hpp)
10 {
11         return scnprintf(hpp->buf, hpp->size, "Overhead");
12 }
13
14 static int hpp__width_overhead(struct perf_hpp *hpp __maybe_unused)
15 {
16         return 8;
17 }
18
19 static int hpp__color_overhead(struct perf_hpp *hpp, struct hist_entry *he)
20 {
21         struct hists *hists = he->hists;
22         double percent = 100.0 * he->stat.period / hists->stats.total_period;
23
24         return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%%", percent);
25 }
26
27 static int hpp__entry_overhead(struct perf_hpp *hpp, struct hist_entry *he)
28 {
29         struct hists *hists = he->hists;
30         double percent = 100.0 * he->stat.period / hists->stats.total_period;
31         const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%%";
32
33         return scnprintf(hpp->buf, hpp->size, fmt, percent);
34 }
35
36 static int hpp__header_overhead_sys(struct perf_hpp *hpp)
37 {
38         const char *fmt = symbol_conf.field_sep ? "%s" : "%7s";
39
40         return scnprintf(hpp->buf, hpp->size, fmt, "sys");
41 }
42
43 static int hpp__width_overhead_sys(struct perf_hpp *hpp __maybe_unused)
44 {
45         return 7;
46 }
47
48 static int hpp__color_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he)
49 {
50         struct hists *hists = he->hists;
51         double percent = 100.0 * he->stat.period_sys / hists->stats.total_period;
52
53         return percent_color_snprintf(hpp->buf, hpp->size, "%6.2f%%", percent);
54 }
55
56 static int hpp__entry_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he)
57 {
58         struct hists *hists = he->hists;
59         double percent = 100.0 * he->stat.period_sys / hists->stats.total_period;
60         const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%";
61
62         return scnprintf(hpp->buf, hpp->size, fmt, percent);
63 }
64
65 static int hpp__header_overhead_us(struct perf_hpp *hpp)
66 {
67         const char *fmt = symbol_conf.field_sep ? "%s" : "%7s";
68
69         return scnprintf(hpp->buf, hpp->size, fmt, "user");
70 }
71
72 static int hpp__width_overhead_us(struct perf_hpp *hpp __maybe_unused)
73 {
74         return 7;
75 }
76
77 static int hpp__color_overhead_us(struct perf_hpp *hpp, struct hist_entry *he)
78 {
79         struct hists *hists = he->hists;
80         double percent = 100.0 * he->stat.period_us / hists->stats.total_period;
81
82         return percent_color_snprintf(hpp->buf, hpp->size, "%6.2f%%", percent);
83 }
84
85 static int hpp__entry_overhead_us(struct perf_hpp *hpp, struct hist_entry *he)
86 {
87         struct hists *hists = he->hists;
88         double percent = 100.0 * he->stat.period_us / hists->stats.total_period;
89         const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%";
90
91         return scnprintf(hpp->buf, hpp->size, fmt, percent);
92 }
93
94 static int hpp__header_overhead_guest_sys(struct perf_hpp *hpp)
95 {
96         return scnprintf(hpp->buf, hpp->size, "guest sys");
97 }
98
99 static int hpp__width_overhead_guest_sys(struct perf_hpp *hpp __maybe_unused)
100 {
101         return 9;
102 }
103
104 static int hpp__color_overhead_guest_sys(struct perf_hpp *hpp,
105                                          struct hist_entry *he)
106 {
107         struct hists *hists = he->hists;
108         double percent = 100.0 * he->stat.period_guest_sys / hists->stats.total_period;
109
110         return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%% ", percent);
111 }
112
113 static int hpp__entry_overhead_guest_sys(struct perf_hpp *hpp,
114                                          struct hist_entry *he)
115 {
116         struct hists *hists = he->hists;
117         double percent = 100.0 * he->stat.period_guest_sys / hists->stats.total_period;
118         const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%% ";
119
120         return scnprintf(hpp->buf, hpp->size, fmt, percent);
121 }
122
123 static int hpp__header_overhead_guest_us(struct perf_hpp *hpp)
124 {
125         return scnprintf(hpp->buf, hpp->size, "guest usr");
126 }
127
128 static int hpp__width_overhead_guest_us(struct perf_hpp *hpp __maybe_unused)
129 {
130         return 9;
131 }
132
133 static int hpp__color_overhead_guest_us(struct perf_hpp *hpp,
134                                         struct hist_entry *he)
135 {
136         struct hists *hists = he->hists;
137         double percent = 100.0 * he->stat.period_guest_us / hists->stats.total_period;
138
139         return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%% ", percent);
140 }
141
142 static int hpp__entry_overhead_guest_us(struct perf_hpp *hpp,
143                                         struct hist_entry *he)
144 {
145         struct hists *hists = he->hists;
146         double percent = 100.0 * he->stat.period_guest_us / hists->stats.total_period;
147         const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%% ";
148
149         return scnprintf(hpp->buf, hpp->size, fmt, percent);
150 }
151
152 static int hpp__header_baseline(struct perf_hpp *hpp)
153 {
154         return scnprintf(hpp->buf, hpp->size, "Baseline");
155 }
156
157 static int hpp__width_baseline(struct perf_hpp *hpp __maybe_unused)
158 {
159         return 8;
160 }
161
162 static double baseline_percent(struct hist_entry *he)
163 {
164         struct hist_entry *pair = hist_entry__next_pair(he);
165         struct hists *pair_hists = pair ? pair->hists : NULL;
166         double percent = 0.0;
167
168         if (pair) {
169                 u64 total_period = pair_hists->stats.total_period;
170                 u64 base_period  = pair->stat.period;
171
172                 percent = 100.0 * base_period / total_period;
173         }
174
175         return percent;
176 }
177
178 static int hpp__color_baseline(struct perf_hpp *hpp, struct hist_entry *he)
179 {
180         double percent = baseline_percent(he);
181
182         if (hist_entry__has_pairs(he))
183                 return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%%", percent);
184         else
185                 return scnprintf(hpp->buf, hpp->size, "        ");
186 }
187
188 static int hpp__entry_baseline(struct perf_hpp *hpp, struct hist_entry *he)
189 {
190         double percent = baseline_percent(he);
191         const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%%";
192
193         if (hist_entry__has_pairs(he) || symbol_conf.field_sep)
194                 return scnprintf(hpp->buf, hpp->size, fmt, percent);
195         else
196                 return scnprintf(hpp->buf, hpp->size, "            ");
197 }
198
199 static int hpp__header_samples(struct perf_hpp *hpp)
200 {
201         const char *fmt = symbol_conf.field_sep ? "%s" : "%11s";
202
203         return scnprintf(hpp->buf, hpp->size, fmt, "Samples");
204 }
205
206 static int hpp__width_samples(struct perf_hpp *hpp __maybe_unused)
207 {
208         return 11;
209 }
210
211 static int hpp__entry_samples(struct perf_hpp *hpp, struct hist_entry *he)
212 {
213         const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%11" PRIu64;
214
215         return scnprintf(hpp->buf, hpp->size, fmt, he->stat.nr_events);
216 }
217
218 static int hpp__header_period(struct perf_hpp *hpp)
219 {
220         const char *fmt = symbol_conf.field_sep ? "%s" : "%12s";
221
222         return scnprintf(hpp->buf, hpp->size, fmt, "Period");
223 }
224
225 static int hpp__width_period(struct perf_hpp *hpp __maybe_unused)
226 {
227         return 12;
228 }
229
230 static int hpp__entry_period(struct perf_hpp *hpp, struct hist_entry *he)
231 {
232         const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%12" PRIu64;
233
234         return scnprintf(hpp->buf, hpp->size, fmt, he->stat.period);
235 }
236
237 static int hpp__header_period_baseline(struct perf_hpp *hpp)
238 {
239         const char *fmt = symbol_conf.field_sep ? "%s" : "%12s";
240
241         return scnprintf(hpp->buf, hpp->size, fmt, "Period Base");
242 }
243
244 static int hpp__width_period_baseline(struct perf_hpp *hpp __maybe_unused)
245 {
246         return 12;
247 }
248
249 static int hpp__entry_period_baseline(struct perf_hpp *hpp, struct hist_entry *he)
250 {
251         struct hist_entry *pair = hist_entry__next_pair(he);
252         u64 period = pair ? pair->stat.period : 0;
253         const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%12" PRIu64;
254
255         return scnprintf(hpp->buf, hpp->size, fmt, period);
256 }
257 static int hpp__header_delta(struct perf_hpp *hpp)
258 {
259         const char *fmt = symbol_conf.field_sep ? "%s" : "%7s";
260
261         return scnprintf(hpp->buf, hpp->size, fmt, "Delta");
262 }
263
264 static int hpp__width_delta(struct perf_hpp *hpp __maybe_unused)
265 {
266         return 7;
267 }
268
269 static int hpp__entry_delta(struct perf_hpp *hpp, struct hist_entry *he)
270 {
271         struct hist_entry *pair = hist_entry__next_pair(he);
272         const char *fmt = symbol_conf.field_sep ? "%s" : "%7.7s";
273         char buf[32] = " ";
274         double diff = 0.0;
275
276         if (pair) {
277                 if (he->diff.computed)
278                         diff = he->diff.period_ratio_delta;
279                 else
280                         diff = perf_diff__compute_delta(he, pair);
281         } else
282                 diff = perf_diff__period_percent(he, he->stat.period);
283
284         if (fabs(diff) >= 0.01)
285                 scnprintf(buf, sizeof(buf), "%+4.2F%%", diff);
286
287         return scnprintf(hpp->buf, hpp->size, fmt, buf);
288 }
289
290 static int hpp__header_ratio(struct perf_hpp *hpp)
291 {
292         const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
293
294         return scnprintf(hpp->buf, hpp->size, fmt, "Ratio");
295 }
296
297 static int hpp__width_ratio(struct perf_hpp *hpp __maybe_unused)
298 {
299         return 14;
300 }
301
302 static int hpp__entry_ratio(struct perf_hpp *hpp, struct hist_entry *he)
303 {
304         struct hist_entry *pair = hist_entry__next_pair(he);
305         const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
306         char buf[32] = " ";
307         double ratio = 0.0;
308
309         if (pair) {
310                 if (he->diff.computed)
311                         ratio = he->diff.period_ratio;
312                 else
313                         ratio = perf_diff__compute_ratio(he, pair);
314         }
315
316         if (ratio > 0.0)
317                 scnprintf(buf, sizeof(buf), "%+14.6F", ratio);
318
319         return scnprintf(hpp->buf, hpp->size, fmt, buf);
320 }
321
322 static int hpp__header_wdiff(struct perf_hpp *hpp)
323 {
324         const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
325
326         return scnprintf(hpp->buf, hpp->size, fmt, "Weighted diff");
327 }
328
329 static int hpp__width_wdiff(struct perf_hpp *hpp __maybe_unused)
330 {
331         return 14;
332 }
333
334 static int hpp__entry_wdiff(struct perf_hpp *hpp, struct hist_entry *he)
335 {
336         struct hist_entry *pair = hist_entry__next_pair(he);
337         const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
338         char buf[32] = " ";
339         s64 wdiff = 0;
340
341         if (pair) {
342                 if (he->diff.computed)
343                         wdiff = he->diff.wdiff;
344                 else
345                         wdiff = perf_diff__compute_wdiff(he, pair);
346         }
347
348         if (wdiff != 0)
349                 scnprintf(buf, sizeof(buf), "%14ld", wdiff);
350
351         return scnprintf(hpp->buf, hpp->size, fmt, buf);
352 }
353
354 static int hpp__header_formula(struct perf_hpp *hpp)
355 {
356         const char *fmt = symbol_conf.field_sep ? "%s" : "%70s";
357
358         return scnprintf(hpp->buf, hpp->size, fmt, "Formula");
359 }
360
361 static int hpp__width_formula(struct perf_hpp *hpp __maybe_unused)
362 {
363         return 70;
364 }
365
366 static int hpp__entry_formula(struct perf_hpp *hpp, struct hist_entry *he)
367 {
368         struct hist_entry *pair = hist_entry__next_pair(he);
369         const char *fmt = symbol_conf.field_sep ? "%s" : "%-70s";
370         char buf[96] = " ";
371
372         if (pair)
373                 perf_diff__formula(he, pair, buf, sizeof(buf));
374
375         return scnprintf(hpp->buf, hpp->size, fmt, buf);
376 }
377
378 #define HPP__COLOR_PRINT_FNS(_name)                     \
379         {                                               \
380                 .header = hpp__header_ ## _name,        \
381                 .width  = hpp__width_ ## _name,         \
382                 .color  = hpp__color_ ## _name,         \
383                 .entry  = hpp__entry_ ## _name          \
384         }
385
386 #define HPP__PRINT_FNS(_name)                           \
387         {                                               \
388                 .header = hpp__header_ ## _name,        \
389                 .width  = hpp__width_ ## _name,         \
390                 .entry  = hpp__entry_ ## _name          \
391         }
392
393 struct perf_hpp_fmt perf_hpp__format[] = {
394         HPP__COLOR_PRINT_FNS(baseline),
395         HPP__COLOR_PRINT_FNS(overhead),
396         HPP__COLOR_PRINT_FNS(overhead_sys),
397         HPP__COLOR_PRINT_FNS(overhead_us),
398         HPP__COLOR_PRINT_FNS(overhead_guest_sys),
399         HPP__COLOR_PRINT_FNS(overhead_guest_us),
400         HPP__PRINT_FNS(samples),
401         HPP__PRINT_FNS(period),
402         HPP__PRINT_FNS(period_baseline),
403         HPP__PRINT_FNS(delta),
404         HPP__PRINT_FNS(ratio),
405         HPP__PRINT_FNS(wdiff),
406         HPP__PRINT_FNS(formula)
407 };
408
409 LIST_HEAD(perf_hpp__list);
410
411 #undef HPP__COLOR_PRINT_FNS
412 #undef HPP__PRINT_FNS
413
414 void perf_hpp__init(void)
415 {
416         if (symbol_conf.show_cpu_utilization) {
417                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
418                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);
419
420                 if (perf_guest) {
421                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS);
422                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US);
423                 }
424         }
425
426         if (symbol_conf.show_nr_samples)
427                 perf_hpp__column_enable(PERF_HPP__SAMPLES);
428
429         if (symbol_conf.show_total_period)
430                 perf_hpp__column_enable(PERF_HPP__PERIOD);
431 }
432
433 void perf_hpp__column_register(struct perf_hpp_fmt *format)
434 {
435         list_add_tail(&format->list, &perf_hpp__list);
436 }
437
438 void perf_hpp__column_enable(unsigned col)
439 {
440         BUG_ON(col >= PERF_HPP__MAX_INDEX);
441         perf_hpp__column_register(&perf_hpp__format[col]);
442 }
443
444 static inline void advance_hpp(struct perf_hpp *hpp, int inc)
445 {
446         hpp->buf  += inc;
447         hpp->size -= inc;
448 }
449
450 int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he,
451                                 bool color)
452 {
453         const char *sep = symbol_conf.field_sep;
454         struct perf_hpp_fmt *fmt;
455         char *start = hpp->buf;
456         int ret;
457         bool first = true;
458
459         if (symbol_conf.exclude_other && !he->parent)
460                 return 0;
461
462         perf_hpp__for_each_format(fmt) {
463                 /*
464                  * If there's no field_sep, we still need
465                  * to display initial '  '.
466                  */
467                 if (!sep || !first) {
468                         ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
469                         advance_hpp(hpp, ret);
470                 } else
471                         first = false;
472
473                 if (color && fmt->color)
474                         ret = fmt->color(hpp, he);
475                 else
476                         ret = fmt->entry(hpp, he);
477
478                 advance_hpp(hpp, ret);
479         }
480
481         return hpp->buf - start;
482 }
483
484 int hist_entry__sort_snprintf(struct hist_entry *he, char *s, size_t size,
485                               struct hists *hists)
486 {
487         const char *sep = symbol_conf.field_sep;
488         struct sort_entry *se;
489         int ret = 0;
490
491         list_for_each_entry(se, &hist_entry__sort_list, list) {
492                 if (se->elide)
493                         continue;
494
495                 ret += scnprintf(s + ret, size - ret, "%s", sep ?: "  ");
496                 ret += se->se_snprintf(he, s + ret, size - ret,
497                                        hists__col_len(hists, se->se_width_idx));
498         }
499
500         return ret;
501 }
502
503 /*
504  * See hists__fprintf to match the column widths
505  */
506 unsigned int hists__sort_list_width(struct hists *hists)
507 {
508         struct perf_hpp_fmt *fmt;
509         struct sort_entry *se;
510         int i = 0, ret = 0;
511
512         perf_hpp__for_each_format(fmt) {
513                 if (i)
514                         ret += 2;
515
516                 ret += fmt->width(NULL);
517         }
518
519         list_for_each_entry(se, &hist_entry__sort_list, list)
520                 if (!se->elide)
521                         ret += 2 + hists__col_len(hists, se->se_width_idx);
522
523         if (verbose) /* Addr + origin */
524                 ret += 3 + BITS_PER_LONG / 4;
525
526         return ret;
527 }