projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'drm-nouveau-next' of git://anongit.freedesktop.org/git/nouveau/linux...
[deliverable/linux.git] / tools / perf / ui / hist.c
1 #include <math.h>
2 #include <linux/compiler.h>
3
4 #include "../util/hist.h"
5 #include "../util/util.h"
6 #include "../util/sort.h"
7 #include "../util/evsel.h"
8
9 /* hist period print (hpp) functions */
10
11 #define hpp__call_print_fn(hpp, fn, fmt, ...) \
12 ({ \
13 int __ret = fn(hpp, fmt, ##__VA_ARGS__); \
14 advance_hpp(hpp, __ret); \
15 __ret; \
16 })
17
18 int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
19 hpp_field_fn get_field, const char *fmt,
20 hpp_snprint_fn print_fn, bool fmt_percent)
21 {
22 int ret;
23 struct hists *hists = he->hists;
24 struct perf_evsel *evsel = hists_to_evsel(hists);
25 char *buf = hpp->buf;
26 size_t size = hpp->size;
27
28 if (fmt_percent) {
29 double percent = 0.0;
30 u64 total = hists__total_period(hists);
31
32 if (total)
33 percent = 100.0 * get_field(he) / total;
34
35 ret = hpp__call_print_fn(hpp, print_fn, fmt, percent);
36 } else
37 ret = hpp__call_print_fn(hpp, print_fn, fmt, get_field(he));
38
39 if (perf_evsel__is_group_event(evsel)) {
40 int prev_idx, idx_delta;
41 struct hist_entry *pair;
42 int nr_members = evsel->nr_members;
43
44 prev_idx = perf_evsel__group_idx(evsel);
45
46 list_for_each_entry(pair, &he->pairs.head, pairs.node) {
47 u64 period = get_field(pair);
48 u64 total = hists__total_period(pair->hists);
49
50 if (!total)
51 continue;
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 if (fmt_percent) {
62 ret += hpp__call_print_fn(hpp, print_fn,
63 fmt, 0.0);
64 } else {
65 ret += hpp__call_print_fn(hpp, print_fn,
66 fmt, 0ULL);
67 }
68 }
69
70 if (fmt_percent) {
71 ret += hpp__call_print_fn(hpp, print_fn, fmt,
72 100.0 * period / total);
73 } else {
74 ret += hpp__call_print_fn(hpp, print_fn, fmt,
75 period);
76 }
77
78 prev_idx = perf_evsel__group_idx(evsel);
79 }
80
81 idx_delta = nr_members - prev_idx - 1;
82
83 while (idx_delta--) {
84 /*
85 * zero-fill group members at last which have no sample
86 */
87 if (fmt_percent) {
88 ret += hpp__call_print_fn(hpp, print_fn,
89 fmt, 0.0);
90 } else {
91 ret += hpp__call_print_fn(hpp, print_fn,
92 fmt, 0ULL);
93 }
94 }
95 }
96
97 /*
98 * Restore original buf and size as it's where caller expects
99 * the result will be saved.
100 */
101 hpp->buf = buf;
102 hpp->size = size;
103
104 return ret;
105 }
106
107 int __hpp__fmt_acc(struct perf_hpp *hpp, struct hist_entry *he,
108 hpp_field_fn get_field, const char *fmt,
109 hpp_snprint_fn print_fn, bool fmt_percent)
110 {
111 if (!symbol_conf.cumulate_callchain) {
112 return snprintf(hpp->buf, hpp->size, "%*s",
113 fmt_percent ? 8 : 12, "N/A");
114 }
115
116 return __hpp__fmt(hpp, he, get_field, fmt, print_fn, fmt_percent);
117 }
118
119 static int field_cmp(u64 field_a, u64 field_b)
120 {
121 if (field_a > field_b)
122 return 1;
123 if (field_a < field_b)
124 return -1;
125 return 0;
126 }
127
128 static int __hpp__sort(struct hist_entry *a, struct hist_entry *b,
129 hpp_field_fn get_field)
130 {
131 s64 ret;
132 int i, nr_members;
133 struct perf_evsel *evsel;
134 struct hist_entry *pair;
135 u64 *fields_a, *fields_b;
136
137 ret = field_cmp(get_field(a), get_field(b));
138 if (ret || !symbol_conf.event_group)
139 return ret;
140
141 evsel = hists_to_evsel(a->hists);
142 if (!perf_evsel__is_group_event(evsel))
143 return ret;
144
145 nr_members = evsel->nr_members;
146 fields_a = calloc(sizeof(*fields_a), nr_members);
147 fields_b = calloc(sizeof(*fields_b), nr_members);
148
149 if (!fields_a || !fields_b)
150 goto out;
151
152 list_for_each_entry(pair, &a->pairs.head, pairs.node) {
153 evsel = hists_to_evsel(pair->hists);
154 fields_a[perf_evsel__group_idx(evsel)] = get_field(pair);
155 }
156
157 list_for_each_entry(pair, &b->pairs.head, pairs.node) {
158 evsel = hists_to_evsel(pair->hists);
159 fields_b[perf_evsel__group_idx(evsel)] = get_field(pair);
160 }
161
162 for (i = 1; i < nr_members; i++) {
163 ret = field_cmp(fields_a[i], fields_b[i]);
164 if (ret)
165 break;
166 }
167
168 out:
169 free(fields_a);
170 free(fields_b);
171
172 return ret;
173 }
174
175 static int __hpp__sort_acc(struct hist_entry *a, struct hist_entry *b,
176 hpp_field_fn get_field)
177 {
178 s64 ret = 0;
179
180 if (symbol_conf.cumulate_callchain) {
181 /*
182 * Put caller above callee when they have equal period.
183 */
184 ret = field_cmp(get_field(a), get_field(b));
185 if (ret)
186 return ret;
187
188 ret = b->callchain->max_depth - a->callchain->max_depth;
189 }
190 return ret;
191 }
192
193 #define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \
194 static int hpp__header_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
195 struct perf_hpp *hpp, \
196 struct perf_evsel *evsel) \
197 { \
198 int len = _min_width; \
199 \
200 if (symbol_conf.event_group) \
201 len = max(len, evsel->nr_members * _unit_width); \
202 \
203 return scnprintf(hpp->buf, hpp->size, "%*s", len, _str); \
204 }
205
206 #define __HPP_WIDTH_FN(_type, _min_width, _unit_width) \
207 static int hpp__width_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
208 struct perf_hpp *hpp __maybe_unused, \
209 struct perf_evsel *evsel) \
210 { \
211 int len = _min_width; \
212 \
213 if (symbol_conf.event_group) \
214 len = max(len, evsel->nr_members * _unit_width); \
215 \
216 return len; \
217 }
218
219 static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
220 {
221 va_list args;
222 ssize_t ssize = hpp->size;
223 double percent;
224 int ret;
225
226 va_start(args, fmt);
227 percent = va_arg(args, double);
228 ret = value_color_snprintf(hpp->buf, hpp->size, fmt, percent);
229 va_end(args);
230
231 return (ret >= ssize) ? (ssize - 1) : ret;
232 }
233
234 static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
235 {
236 va_list args;
237 ssize_t ssize = hpp->size;
238 int ret;
239
240 va_start(args, fmt);
241 ret = vsnprintf(hpp->buf, hpp->size, fmt, args);
242 va_end(args);
243
244 return (ret >= ssize) ? (ssize - 1) : ret;
245 }
246
247 #define __HPP_COLOR_PERCENT_FN(_type, _field) \
248 static u64 he_get_##_field(struct hist_entry *he) \
249 { \
250 return he->stat._field; \
251 } \
252 \
253 static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
254 struct perf_hpp *hpp, struct hist_entry *he) \
255 { \
256 return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%", \
257 hpp_color_scnprintf, true); \
258 }
259
260 #define __HPP_ENTRY_PERCENT_FN(_type, _field) \
261 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \
262 struct perf_hpp *hpp, struct hist_entry *he) \
263 { \
264 const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%"; \
265 return __hpp__fmt(hpp, he, he_get_##_field, fmt, \
266 hpp_entry_scnprintf, true); \
267 }
268
269 #define __HPP_SORT_FN(_type, _field) \
270 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \
271 { \
272 return __hpp__sort(a, b, he_get_##_field); \
273 }
274
275 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \
276 static u64 he_get_acc_##_field(struct hist_entry *he) \
277 { \
278 return he->stat_acc->_field; \
279 } \
280 \
281 static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
282 struct perf_hpp *hpp, struct hist_entry *he) \
283 { \
284 return __hpp__fmt_acc(hpp, he, he_get_acc_##_field, " %6.2f%%", \
285 hpp_color_scnprintf, true); \
286 }
287
288 #define __HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \
289 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \
290 struct perf_hpp *hpp, struct hist_entry *he) \
291 { \
292 const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%"; \
293 return __hpp__fmt_acc(hpp, he, he_get_acc_##_field, fmt, \
294 hpp_entry_scnprintf, true); \
295 }
296
297 #define __HPP_SORT_ACC_FN(_type, _field) \
298 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \
299 { \
300 return __hpp__sort_acc(a, b, he_get_acc_##_field); \
301 }
302
303 #define __HPP_ENTRY_RAW_FN(_type, _field) \
304 static u64 he_get_raw_##_field(struct hist_entry *he) \
305 { \
306 return he->stat._field; \
307 } \
308 \
309 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \
310 struct perf_hpp *hpp, struct hist_entry *he) \
311 { \
312 const char *fmt = symbol_conf.field_sep ? " %"PRIu64 : " %11"PRIu64; \
313 return __hpp__fmt(hpp, he, he_get_raw_##_field, fmt, \
314 hpp_entry_scnprintf, false); \
315 }
316
317 #define __HPP_SORT_RAW_FN(_type, _field) \
318 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \
319 { \
320 return __hpp__sort(a, b, he_get_raw_##_field); \
321 }
322
323
324 #define HPP_PERCENT_FNS(_type, _str, _field, _min_width, _unit_width) \
325 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \
326 __HPP_WIDTH_FN(_type, _min_width, _unit_width) \
327 __HPP_COLOR_PERCENT_FN(_type, _field) \
328 __HPP_ENTRY_PERCENT_FN(_type, _field) \
329 __HPP_SORT_FN(_type, _field)
330
331 #define HPP_PERCENT_ACC_FNS(_type, _str, _field, _min_width, _unit_width)\
332 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \
333 __HPP_WIDTH_FN(_type, _min_width, _unit_width) \
334 __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \
335 __HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \
336 __HPP_SORT_ACC_FN(_type, _field)
337
338 #define HPP_RAW_FNS(_type, _str, _field, _min_width, _unit_width) \
339 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \
340 __HPP_WIDTH_FN(_type, _min_width, _unit_width) \
341 __HPP_ENTRY_RAW_FN(_type, _field) \
342 __HPP_SORT_RAW_FN(_type, _field)
343
344 __HPP_HEADER_FN(overhead_self, "Self", 8, 8)
345
346 HPP_PERCENT_FNS(overhead, "Overhead", period, 8, 8)
347 HPP_PERCENT_FNS(overhead_sys, "sys", period_sys, 8, 8)
348 HPP_PERCENT_FNS(overhead_us, "usr", period_us, 8, 8)
349 HPP_PERCENT_FNS(overhead_guest_sys, "guest sys", period_guest_sys, 9, 8)
350 HPP_PERCENT_FNS(overhead_guest_us, "guest usr", period_guest_us, 9, 8)
351 HPP_PERCENT_ACC_FNS(overhead_acc, "Children", period, 8, 8)
352
353 HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12)
354 HPP_RAW_FNS(period, "Period", period, 12, 12)
355
356 static int64_t hpp__nop_cmp(struct hist_entry *a __maybe_unused,
357 struct hist_entry *b __maybe_unused)
358 {
359 return 0;
360 }
361
362 #define HPP__COLOR_PRINT_FNS(_name) \
363 { \
364 .header = hpp__header_ ## _name, \
365 .width = hpp__width_ ## _name, \
366 .color = hpp__color_ ## _name, \
367 .entry = hpp__entry_ ## _name, \
368 .cmp = hpp__nop_cmp, \
369 .collapse = hpp__nop_cmp, \
370 .sort = hpp__sort_ ## _name, \
371 }
372
373 #define HPP__COLOR_ACC_PRINT_FNS(_name) \
374 { \
375 .header = hpp__header_ ## _name, \
376 .width = hpp__width_ ## _name, \
377 .color = hpp__color_ ## _name, \
378 .entry = hpp__entry_ ## _name, \
379 .cmp = hpp__nop_cmp, \
380 .collapse = hpp__nop_cmp, \
381 .sort = hpp__sort_ ## _name, \
382 }
383
384 #define HPP__PRINT_FNS(_name) \
385 { \
386 .header = hpp__header_ ## _name, \
387 .width = hpp__width_ ## _name, \
388 .entry = hpp__entry_ ## _name, \
389 .cmp = hpp__nop_cmp, \
390 .collapse = hpp__nop_cmp, \
391 .sort = hpp__sort_ ## _name, \
392 }
393
394 struct perf_hpp_fmt perf_hpp__format[] = {
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__COLOR_ACC_PRINT_FNS(overhead_acc),
401 HPP__PRINT_FNS(samples),
402 HPP__PRINT_FNS(period)
403 };
404
405 LIST_HEAD(perf_hpp__list);
406 LIST_HEAD(perf_hpp__sort_list);
407
408
409 #undef HPP__COLOR_PRINT_FNS
410 #undef HPP__COLOR_ACC_PRINT_FNS
411 #undef HPP__PRINT_FNS
412
413 #undef HPP_PERCENT_FNS
414 #undef HPP_PERCENT_ACC_FNS
415 #undef HPP_RAW_FNS
416
417 #undef __HPP_HEADER_FN
418 #undef __HPP_WIDTH_FN
419 #undef __HPP_COLOR_PERCENT_FN
420 #undef __HPP_ENTRY_PERCENT_FN
421 #undef __HPP_COLOR_ACC_PERCENT_FN
422 #undef __HPP_ENTRY_ACC_PERCENT_FN
423 #undef __HPP_ENTRY_RAW_FN
424 #undef __HPP_SORT_FN
425 #undef __HPP_SORT_ACC_FN
426 #undef __HPP_SORT_RAW_FN
427
428
429 void perf_hpp__init(void)
430 {
431 struct list_head *list;
432 int i;
433
434 for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
435 struct perf_hpp_fmt *fmt = &perf_hpp__format[i];
436
437 INIT_LIST_HEAD(&fmt->list);
438
439 /* sort_list may be linked by setup_sorting() */
440 if (fmt->sort_list.next == NULL)
441 INIT_LIST_HEAD(&fmt->sort_list);
442 }
443
444 /*
445 * If user specified field order, no need to setup default fields.
446 */
447 if (field_order)
448 return;
449
450 if (symbol_conf.cumulate_callchain) {
451 perf_hpp__column_enable(PERF_HPP__OVERHEAD_ACC);
452
453 perf_hpp__format[PERF_HPP__OVERHEAD].header =
454 hpp__header_overhead_self;
455 }
456
457 perf_hpp__column_enable(PERF_HPP__OVERHEAD);
458
459 if (symbol_conf.show_cpu_utilization) {
460 perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
461 perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);
462
463 if (perf_guest) {
464 perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS);
465 perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US);
466 }
467 }
468
469 if (symbol_conf.show_nr_samples)
470 perf_hpp__column_enable(PERF_HPP__SAMPLES);
471
472 if (symbol_conf.show_total_period)
473 perf_hpp__column_enable(PERF_HPP__PERIOD);
474
475 /* prepend overhead field for backward compatiblity. */
476 list = &perf_hpp__format[PERF_HPP__OVERHEAD].sort_list;
477 if (list_empty(list))
478 list_add(list, &perf_hpp__sort_list);
479
480 if (symbol_conf.cumulate_callchain) {
481 list = &perf_hpp__format[PERF_HPP__OVERHEAD_ACC].sort_list;
482 if (list_empty(list))
483 list_add(list, &perf_hpp__sort_list);
484 }
485 }
486
487 void perf_hpp__column_register(struct perf_hpp_fmt *format)
488 {
489 list_add_tail(&format->list, &perf_hpp__list);
490 }
491
492 void perf_hpp__column_unregister(struct perf_hpp_fmt *format)
493 {
494 list_del(&format->list);
495 }
496
497 void perf_hpp__register_sort_field(struct perf_hpp_fmt *format)
498 {
499 list_add_tail(&format->sort_list, &perf_hpp__sort_list);
500 }
501
502 void perf_hpp__column_enable(unsigned col)
503 {
504 BUG_ON(col >= PERF_HPP__MAX_INDEX);
505 perf_hpp__column_register(&perf_hpp__format[col]);
506 }
507
508 void perf_hpp__column_disable(unsigned col)
509 {
510 BUG_ON(col >= PERF_HPP__MAX_INDEX);
511 perf_hpp__column_unregister(&perf_hpp__format[col]);
512 }
513
514 void perf_hpp__cancel_cumulate(void)
515 {
516 if (field_order)
517 return;
518
519 perf_hpp__column_disable(PERF_HPP__OVERHEAD_ACC);
520 perf_hpp__format[PERF_HPP__OVERHEAD].header = hpp__header_overhead;
521 }
522
523 void perf_hpp__setup_output_field(void)
524 {
525 struct perf_hpp_fmt *fmt;
526
527 /* append sort keys to output field */
528 perf_hpp__for_each_sort_list(fmt) {
529 if (!list_empty(&fmt->list))
530 continue;
531
532 /*
533 * sort entry fields are dynamically created,
534 * so they can share a same sort key even though
535 * the list is empty.
536 */
537 if (perf_hpp__is_sort_entry(fmt)) {
538 struct perf_hpp_fmt *pos;
539
540 perf_hpp__for_each_format(pos) {
541 if (perf_hpp__same_sort_entry(pos, fmt))
542 goto next;
543 }
544 }
545
546 perf_hpp__column_register(fmt);
547 next:
548 continue;
549 }
550 }
551
552 void perf_hpp__append_sort_keys(void)
553 {
554 struct perf_hpp_fmt *fmt;
555
556 /* append output fields to sort keys */
557 perf_hpp__for_each_format(fmt) {
558 if (!list_empty(&fmt->sort_list))
559 continue;
560
561 /*
562 * sort entry fields are dynamically created,
563 * so they can share a same sort key even though
564 * the list is empty.
565 */
566 if (perf_hpp__is_sort_entry(fmt)) {
567 struct perf_hpp_fmt *pos;
568
569 perf_hpp__for_each_sort_list(pos) {
570 if (perf_hpp__same_sort_entry(pos, fmt))
571 goto next;
572 }
573 }
574
575 perf_hpp__register_sort_field(fmt);
576 next:
577 continue;
578 }
579 }
580
581 void perf_hpp__reset_output_field(void)
582 {
583 struct perf_hpp_fmt *fmt, *tmp;
584
585 /* reset output fields */
586 perf_hpp__for_each_format_safe(fmt, tmp) {
587 list_del_init(&fmt->list);
588 list_del_init(&fmt->sort_list);
589 }
590
591 /* reset sort keys */
592 perf_hpp__for_each_sort_list_safe(fmt, tmp) {
593 list_del_init(&fmt->list);
594 list_del_init(&fmt->sort_list);
595 }
596 }
597
598 /*
599 * See hists__fprintf to match the column widths
600 */
601 unsigned int hists__sort_list_width(struct hists *hists)
602 {
603 struct perf_hpp_fmt *fmt;
604 int ret = 0;
605 bool first = true;
606 struct perf_hpp dummy_hpp;
607
608 perf_hpp__for_each_format(fmt) {
609 if (perf_hpp__should_skip(fmt))
610 continue;
611
612 if (first)
613 first = false;
614 else
615 ret += 2;
616
617 ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
618 }
619
620 if (verbose && sort__has_sym) /* Addr + origin */
621 ret += 3 + BITS_PER_LONG / 4;
622
623 return ret;
624 }
Linux kernel - Deliverables
This page took 0.073652 seconds and 6 git commands to generate.