projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'perf-core-for-mingo-2' of git://git.kernel.org/pub/scm/linux/kernel/git...
[deliverable/linux.git] / tools / perf / util / sort.c
1 #include <sys/mman.h>
2 #include "sort.h"
3 #include "hist.h"
4 #include "comm.h"
5 #include "symbol.h"
6 #include "evsel.h"
7
8 regex_t parent_regex;
9 const char default_parent_pattern[] = "^sys_|^do_page_fault";
10 const char *parent_pattern = default_parent_pattern;
11 const char default_sort_order[] = "comm,dso,symbol";
12 const char default_branch_sort_order[] = "comm,dso_from,symbol_from,symbol_to,cycles";
13 const char default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked";
14 const char default_top_sort_order[] = "dso,symbol";
15 const char default_diff_sort_order[] = "dso,symbol";
16 const char *sort_order;
17 const char *field_order;
18 regex_t ignore_callees_regex;
19 int have_ignore_callees = 0;
20 int sort__need_collapse = 0;
21 int sort__has_parent = 0;
22 int sort__has_sym = 0;
23 int sort__has_dso = 0;
24 int sort__has_socket = 0;
25 enum sort_mode sort__mode = SORT_MODE__NORMAL;
26
27
28 static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
29 {
30 int n;
31 va_list ap;
32
33 va_start(ap, fmt);
34 n = vsnprintf(bf, size, fmt, ap);
35 if (symbol_conf.field_sep && n > 0) {
36 char *sep = bf;
37
38 while (1) {
39 sep = strchr(sep, *symbol_conf.field_sep);
40 if (sep == NULL)
41 break;
42 *sep = '.';
43 }
44 }
45 va_end(ap);
46
47 if (n >= (int)size)
48 return size - 1;
49 return n;
50 }
51
52 static int64_t cmp_null(const void *l, const void *r)
53 {
54 if (!l && !r)
55 return 0;
56 else if (!l)
57 return -1;
58 else
59 return 1;
60 }
61
62 /* --sort pid */
63
64 static int64_t
65 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
66 {
67 return right->thread->tid - left->thread->tid;
68 }
69
70 static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
71 size_t size, unsigned int width)
72 {
73 const char *comm = thread__comm_str(he->thread);
74
75 width = max(7U, width) - 6;
76 return repsep_snprintf(bf, size, "%5d:%-*.*s", he->thread->tid,
77 width, width, comm ?: "");
78 }
79
80 struct sort_entry sort_thread = {
81 .se_header = " Pid:Command",
82 .se_cmp = sort__thread_cmp,
83 .se_snprintf = hist_entry__thread_snprintf,
84 .se_width_idx = HISTC_THREAD,
85 };
86
87 /* --sort comm */
88
89 static int64_t
90 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
91 {
92 /* Compare the addr that should be unique among comm */
93 return strcmp(comm__str(right->comm), comm__str(left->comm));
94 }
95
96 static int64_t
97 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
98 {
99 /* Compare the addr that should be unique among comm */
100 return strcmp(comm__str(right->comm), comm__str(left->comm));
101 }
102
103 static int64_t
104 sort__comm_sort(struct hist_entry *left, struct hist_entry *right)
105 {
106 return strcmp(comm__str(right->comm), comm__str(left->comm));
107 }
108
109 static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf,
110 size_t size, unsigned int width)
111 {
112 return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm));
113 }
114
115 struct sort_entry sort_comm = {
116 .se_header = "Command",
117 .se_cmp = sort__comm_cmp,
118 .se_collapse = sort__comm_collapse,
119 .se_sort = sort__comm_sort,
120 .se_snprintf = hist_entry__comm_snprintf,
121 .se_width_idx = HISTC_COMM,
122 };
123
124 /* --sort dso */
125
126 static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
127 {
128 struct dso *dso_l = map_l ? map_l->dso : NULL;
129 struct dso *dso_r = map_r ? map_r->dso : NULL;
130 const char *dso_name_l, *dso_name_r;
131
132 if (!dso_l || !dso_r)
133 return cmp_null(dso_r, dso_l);
134
135 if (verbose) {
136 dso_name_l = dso_l->long_name;
137 dso_name_r = dso_r->long_name;
138 } else {
139 dso_name_l = dso_l->short_name;
140 dso_name_r = dso_r->short_name;
141 }
142
143 return strcmp(dso_name_l, dso_name_r);
144 }
145
146 static int64_t
147 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
148 {
149 return _sort__dso_cmp(right->ms.map, left->ms.map);
150 }
151
152 static int _hist_entry__dso_snprintf(struct map *map, char *bf,
153 size_t size, unsigned int width)
154 {
155 if (map && map->dso) {
156 const char *dso_name = !verbose ? map->dso->short_name :
157 map->dso->long_name;
158 return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name);
159 }
160
161 return repsep_snprintf(bf, size, "%-*.*s", width, width, "[unknown]");
162 }
163
164 static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf,
165 size_t size, unsigned int width)
166 {
167 return _hist_entry__dso_snprintf(he->ms.map, bf, size, width);
168 }
169
170 struct sort_entry sort_dso = {
171 .se_header = "Shared Object",
172 .se_cmp = sort__dso_cmp,
173 .se_snprintf = hist_entry__dso_snprintf,
174 .se_width_idx = HISTC_DSO,
175 };
176
177 /* --sort symbol */
178
179 static int64_t _sort__addr_cmp(u64 left_ip, u64 right_ip)
180 {
181 return (int64_t)(right_ip - left_ip);
182 }
183
184 static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
185 {
186 if (!sym_l || !sym_r)
187 return cmp_null(sym_l, sym_r);
188
189 if (sym_l == sym_r)
190 return 0;
191
192 if (sym_l->start != sym_r->start)
193 return (int64_t)(sym_r->start - sym_l->start);
194
195 return (int64_t)(sym_r->end - sym_l->end);
196 }
197
198 static int64_t
199 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
200 {
201 int64_t ret;
202
203 if (!left->ms.sym && !right->ms.sym)
204 return _sort__addr_cmp(left->ip, right->ip);
205
206 /*
207 * comparing symbol address alone is not enough since it's a
208 * relative address within a dso.
209 */
210 if (!sort__has_dso) {
211 ret = sort__dso_cmp(left, right);
212 if (ret != 0)
213 return ret;
214 }
215
216 return _sort__sym_cmp(left->ms.sym, right->ms.sym);
217 }
218
219 static int64_t
220 sort__sym_sort(struct hist_entry *left, struct hist_entry *right)
221 {
222 if (!left->ms.sym || !right->ms.sym)
223 return cmp_null(left->ms.sym, right->ms.sym);
224
225 return strcmp(right->ms.sym->name, left->ms.sym->name);
226 }
227
228 static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
229 u64 ip, char level, char *bf, size_t size,
230 unsigned int width)
231 {
232 size_t ret = 0;
233
234 if (verbose) {
235 char o = map ? dso__symtab_origin(map->dso) : '!';
236 ret += repsep_snprintf(bf, size, "%-#*llx %c ",
237 BITS_PER_LONG / 4 + 2, ip, o);
238 }
239
240 ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
241 if (sym && map) {
242 if (map->type == MAP__VARIABLE) {
243 ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
244 ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
245 ip - map->unmap_ip(map, sym->start));
246 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
247 width - ret, "");
248 } else {
249 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
250 width - ret,
251 sym->name);
252 }
253 } else {
254 size_t len = BITS_PER_LONG / 4;
255 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
256 len, ip);
257 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
258 width - ret, "");
259 }
260
261 if (ret > width)
262 bf[width] = '\0';
263
264 return width;
265 }
266
267 static int hist_entry__sym_snprintf(struct hist_entry *he, char *bf,
268 size_t size, unsigned int width)
269 {
270 return _hist_entry__sym_snprintf(he->ms.map, he->ms.sym, he->ip,
271 he->level, bf, size, width);
272 }
273
274 struct sort_entry sort_sym = {
275 .se_header = "Symbol",
276 .se_cmp = sort__sym_cmp,
277 .se_sort = sort__sym_sort,
278 .se_snprintf = hist_entry__sym_snprintf,
279 .se_width_idx = HISTC_SYMBOL,
280 };
281
282 /* --sort srcline */
283
284 static int64_t
285 sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
286 {
287 if (!left->srcline) {
288 if (!left->ms.map)
289 left->srcline = SRCLINE_UNKNOWN;
290 else {
291 struct map *map = left->ms.map;
292 left->srcline = get_srcline(map->dso,
293 map__rip_2objdump(map, left->ip),
294 left->ms.sym, true);
295 }
296 }
297 if (!right->srcline) {
298 if (!right->ms.map)
299 right->srcline = SRCLINE_UNKNOWN;
300 else {
301 struct map *map = right->ms.map;
302 right->srcline = get_srcline(map->dso,
303 map__rip_2objdump(map, right->ip),
304 right->ms.sym, true);
305 }
306 }
307 return strcmp(right->srcline, left->srcline);
308 }
309
310 static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf,
311 size_t size, unsigned int width)
312 {
313 return repsep_snprintf(bf, size, "%-*.*s", width, width, he->srcline);
314 }
315
316 struct sort_entry sort_srcline = {
317 .se_header = "Source:Line",
318 .se_cmp = sort__srcline_cmp,
319 .se_snprintf = hist_entry__srcline_snprintf,
320 .se_width_idx = HISTC_SRCLINE,
321 };
322
323 /* --sort srcfile */
324
325 static char no_srcfile[1];
326
327 static char *get_srcfile(struct hist_entry *e)
328 {
329 char *sf, *p;
330 struct map *map = e->ms.map;
331
332 sf = __get_srcline(map->dso, map__rip_2objdump(map, e->ip),
333 e->ms.sym, false, true);
334 if (!strcmp(sf, SRCLINE_UNKNOWN))
335 return no_srcfile;
336 p = strchr(sf, ':');
337 if (p && *sf) {
338 *p = 0;
339 return sf;
340 }
341 free(sf);
342 return no_srcfile;
343 }
344
345 static int64_t
346 sort__srcfile_cmp(struct hist_entry *left, struct hist_entry *right)
347 {
348 if (!left->srcfile) {
349 if (!left->ms.map)
350 left->srcfile = no_srcfile;
351 else
352 left->srcfile = get_srcfile(left);
353 }
354 if (!right->srcfile) {
355 if (!right->ms.map)
356 right->srcfile = no_srcfile;
357 else
358 right->srcfile = get_srcfile(right);
359 }
360 return strcmp(right->srcfile, left->srcfile);
361 }
362
363 static int hist_entry__srcfile_snprintf(struct hist_entry *he, char *bf,
364 size_t size, unsigned int width)
365 {
366 return repsep_snprintf(bf, size, "%-*.*s", width, width, he->srcfile);
367 }
368
369 struct sort_entry sort_srcfile = {
370 .se_header = "Source File",
371 .se_cmp = sort__srcfile_cmp,
372 .se_snprintf = hist_entry__srcfile_snprintf,
373 .se_width_idx = HISTC_SRCFILE,
374 };
375
376 /* --sort parent */
377
378 static int64_t
379 sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
380 {
381 struct symbol *sym_l = left->parent;
382 struct symbol *sym_r = right->parent;
383
384 if (!sym_l || !sym_r)
385 return cmp_null(sym_l, sym_r);
386
387 return strcmp(sym_r->name, sym_l->name);
388 }
389
390 static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf,
391 size_t size, unsigned int width)
392 {
393 return repsep_snprintf(bf, size, "%-*.*s", width, width,
394 he->parent ? he->parent->name : "[other]");
395 }
396
397 struct sort_entry sort_parent = {
398 .se_header = "Parent symbol",
399 .se_cmp = sort__parent_cmp,
400 .se_snprintf = hist_entry__parent_snprintf,
401 .se_width_idx = HISTC_PARENT,
402 };
403
404 /* --sort cpu */
405
406 static int64_t
407 sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
408 {
409 return right->cpu - left->cpu;
410 }
411
412 static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf,
413 size_t size, unsigned int width)
414 {
415 return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu);
416 }
417
418 struct sort_entry sort_cpu = {
419 .se_header = "CPU",
420 .se_cmp = sort__cpu_cmp,
421 .se_snprintf = hist_entry__cpu_snprintf,
422 .se_width_idx = HISTC_CPU,
423 };
424
425 /* --sort socket */
426
427 static int64_t
428 sort__socket_cmp(struct hist_entry *left, struct hist_entry *right)
429 {
430 return right->socket - left->socket;
431 }
432
433 static int hist_entry__socket_snprintf(struct hist_entry *he, char *bf,
434 size_t size, unsigned int width)
435 {
436 return repsep_snprintf(bf, size, "%*.*d", width, width-3, he->socket);
437 }
438
439 struct sort_entry sort_socket = {
440 .se_header = "Socket",
441 .se_cmp = sort__socket_cmp,
442 .se_snprintf = hist_entry__socket_snprintf,
443 .se_width_idx = HISTC_SOCKET,
444 };
445
446 /* sort keys for branch stacks */
447
448 static int64_t
449 sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
450 {
451 if (!left->branch_info || !right->branch_info)
452 return cmp_null(left->branch_info, right->branch_info);
453
454 return _sort__dso_cmp(left->branch_info->from.map,
455 right->branch_info->from.map);
456 }
457
458 static int hist_entry__dso_from_snprintf(struct hist_entry *he, char *bf,
459 size_t size, unsigned int width)
460 {
461 if (he->branch_info)
462 return _hist_entry__dso_snprintf(he->branch_info->from.map,
463 bf, size, width);
464 else
465 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
466 }
467
468 static int64_t
469 sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
470 {
471 if (!left->branch_info || !right->branch_info)
472 return cmp_null(left->branch_info, right->branch_info);
473
474 return _sort__dso_cmp(left->branch_info->to.map,
475 right->branch_info->to.map);
476 }
477
478 static int hist_entry__dso_to_snprintf(struct hist_entry *he, char *bf,
479 size_t size, unsigned int width)
480 {
481 if (he->branch_info)
482 return _hist_entry__dso_snprintf(he->branch_info->to.map,
483 bf, size, width);
484 else
485 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
486 }
487
488 static int64_t
489 sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
490 {
491 struct addr_map_symbol *from_l = &left->branch_info->from;
492 struct addr_map_symbol *from_r = &right->branch_info->from;
493
494 if (!left->branch_info || !right->branch_info)
495 return cmp_null(left->branch_info, right->branch_info);
496
497 from_l = &left->branch_info->from;
498 from_r = &right->branch_info->from;
499
500 if (!from_l->sym && !from_r->sym)
501 return _sort__addr_cmp(from_l->addr, from_r->addr);
502
503 return _sort__sym_cmp(from_l->sym, from_r->sym);
504 }
505
506 static int64_t
507 sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
508 {
509 struct addr_map_symbol *to_l, *to_r;
510
511 if (!left->branch_info || !right->branch_info)
512 return cmp_null(left->branch_info, right->branch_info);
513
514 to_l = &left->branch_info->to;
515 to_r = &right->branch_info->to;
516
517 if (!to_l->sym && !to_r->sym)
518 return _sort__addr_cmp(to_l->addr, to_r->addr);
519
520 return _sort__sym_cmp(to_l->sym, to_r->sym);
521 }
522
523 static int hist_entry__sym_from_snprintf(struct hist_entry *he, char *bf,
524 size_t size, unsigned int width)
525 {
526 if (he->branch_info) {
527 struct addr_map_symbol *from = &he->branch_info->from;
528
529 return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
530 he->level, bf, size, width);
531 }
532
533 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
534 }
535
536 static int hist_entry__sym_to_snprintf(struct hist_entry *he, char *bf,
537 size_t size, unsigned int width)
538 {
539 if (he->branch_info) {
540 struct addr_map_symbol *to = &he->branch_info->to;
541
542 return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
543 he->level, bf, size, width);
544 }
545
546 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
547 }
548
549 struct sort_entry sort_dso_from = {
550 .se_header = "Source Shared Object",
551 .se_cmp = sort__dso_from_cmp,
552 .se_snprintf = hist_entry__dso_from_snprintf,
553 .se_width_idx = HISTC_DSO_FROM,
554 };
555
556 struct sort_entry sort_dso_to = {
557 .se_header = "Target Shared Object",
558 .se_cmp = sort__dso_to_cmp,
559 .se_snprintf = hist_entry__dso_to_snprintf,
560 .se_width_idx = HISTC_DSO_TO,
561 };
562
563 struct sort_entry sort_sym_from = {
564 .se_header = "Source Symbol",
565 .se_cmp = sort__sym_from_cmp,
566 .se_snprintf = hist_entry__sym_from_snprintf,
567 .se_width_idx = HISTC_SYMBOL_FROM,
568 };
569
570 struct sort_entry sort_sym_to = {
571 .se_header = "Target Symbol",
572 .se_cmp = sort__sym_to_cmp,
573 .se_snprintf = hist_entry__sym_to_snprintf,
574 .se_width_idx = HISTC_SYMBOL_TO,
575 };
576
577 static int64_t
578 sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
579 {
580 unsigned char mp, p;
581
582 if (!left->branch_info || !right->branch_info)
583 return cmp_null(left->branch_info, right->branch_info);
584
585 mp = left->branch_info->flags.mispred != right->branch_info->flags.mispred;
586 p = left->branch_info->flags.predicted != right->branch_info->flags.predicted;
587 return mp || p;
588 }
589
590 static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
591 size_t size, unsigned int width){
592 static const char *out = "N/A";
593
594 if (he->branch_info) {
595 if (he->branch_info->flags.predicted)
596 out = "N";
597 else if (he->branch_info->flags.mispred)
598 out = "Y";
599 }
600
601 return repsep_snprintf(bf, size, "%-*.*s", width, width, out);
602 }
603
604 static int64_t
605 sort__cycles_cmp(struct hist_entry *left, struct hist_entry *right)
606 {
607 return left->branch_info->flags.cycles -
608 right->branch_info->flags.cycles;
609 }
610
611 static int hist_entry__cycles_snprintf(struct hist_entry *he, char *bf,
612 size_t size, unsigned int width)
613 {
614 if (he->branch_info->flags.cycles == 0)
615 return repsep_snprintf(bf, size, "%-*s", width, "-");
616 return repsep_snprintf(bf, size, "%-*hd", width,
617 he->branch_info->flags.cycles);
618 }
619
620 struct sort_entry sort_cycles = {
621 .se_header = "Basic Block Cycles",
622 .se_cmp = sort__cycles_cmp,
623 .se_snprintf = hist_entry__cycles_snprintf,
624 .se_width_idx = HISTC_CYCLES,
625 };
626
627 /* --sort daddr_sym */
628 static int64_t
629 sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
630 {
631 uint64_t l = 0, r = 0;
632
633 if (left->mem_info)
634 l = left->mem_info->daddr.addr;
635 if (right->mem_info)
636 r = right->mem_info->daddr.addr;
637
638 return (int64_t)(r - l);
639 }
640
641 static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf,
642 size_t size, unsigned int width)
643 {
644 uint64_t addr = 0;
645 struct map *map = NULL;
646 struct symbol *sym = NULL;
647
648 if (he->mem_info) {
649 addr = he->mem_info->daddr.addr;
650 map = he->mem_info->daddr.map;
651 sym = he->mem_info->daddr.sym;
652 }
653 return _hist_entry__sym_snprintf(map, sym, addr, he->level, bf, size,
654 width);
655 }
656
657 static int64_t
658 sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
659 {
660 struct map *map_l = NULL;
661 struct map *map_r = NULL;
662
663 if (left->mem_info)
664 map_l = left->mem_info->daddr.map;
665 if (right->mem_info)
666 map_r = right->mem_info->daddr.map;
667
668 return _sort__dso_cmp(map_l, map_r);
669 }
670
671 static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf,
672 size_t size, unsigned int width)
673 {
674 struct map *map = NULL;
675
676 if (he->mem_info)
677 map = he->mem_info->daddr.map;
678
679 return _hist_entry__dso_snprintf(map, bf, size, width);
680 }
681
682 static int64_t
683 sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
684 {
685 union perf_mem_data_src data_src_l;
686 union perf_mem_data_src data_src_r;
687
688 if (left->mem_info)
689 data_src_l = left->mem_info->data_src;
690 else
691 data_src_l.mem_lock = PERF_MEM_LOCK_NA;
692
693 if (right->mem_info)
694 data_src_r = right->mem_info->data_src;
695 else
696 data_src_r.mem_lock = PERF_MEM_LOCK_NA;
697
698 return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
699 }
700
701 static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf,
702 size_t size, unsigned int width)
703 {
704 const char *out;
705 u64 mask = PERF_MEM_LOCK_NA;
706
707 if (he->mem_info)
708 mask = he->mem_info->data_src.mem_lock;
709
710 if (mask & PERF_MEM_LOCK_NA)
711 out = "N/A";
712 else if (mask & PERF_MEM_LOCK_LOCKED)
713 out = "Yes";
714 else
715 out = "No";
716
717 return repsep_snprintf(bf, size, "%-*s", width, out);
718 }
719
720 static int64_t
721 sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
722 {
723 union perf_mem_data_src data_src_l;
724 union perf_mem_data_src data_src_r;
725
726 if (left->mem_info)
727 data_src_l = left->mem_info->data_src;
728 else
729 data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
730
731 if (right->mem_info)
732 data_src_r = right->mem_info->data_src;
733 else
734 data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
735
736 return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
737 }
738
739 static const char * const tlb_access[] = {
740 "N/A",
741 "HIT",
742 "MISS",
743 "L1",
744 "L2",
745 "Walker",
746 "Fault",
747 };
748 #define NUM_TLB_ACCESS (sizeof(tlb_access)/sizeof(const char *))
749
750 static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf,
751 size_t size, unsigned int width)
752 {
753 char out[64];
754 size_t sz = sizeof(out) - 1; /* -1 for null termination */
755 size_t l = 0, i;
756 u64 m = PERF_MEM_TLB_NA;
757 u64 hit, miss;
758
759 out[0] = '\0';
760
761 if (he->mem_info)
762 m = he->mem_info->data_src.mem_dtlb;
763
764 hit = m & PERF_MEM_TLB_HIT;
765 miss = m & PERF_MEM_TLB_MISS;
766
767 /* already taken care of */
768 m &= ~(PERF_MEM_TLB_HIT|PERF_MEM_TLB_MISS);
769
770 for (i = 0; m && i < NUM_TLB_ACCESS; i++, m >>= 1) {
771 if (!(m & 0x1))
772 continue;
773 if (l) {
774 strcat(out, " or ");
775 l += 4;
776 }
777 strncat(out, tlb_access[i], sz - l);
778 l += strlen(tlb_access[i]);
779 }
780 if (*out == '\0')
781 strcpy(out, "N/A");
782 if (hit)
783 strncat(out, " hit", sz - l);
784 if (miss)
785 strncat(out, " miss", sz - l);
786
787 return repsep_snprintf(bf, size, "%-*s", width, out);
788 }
789
790 static int64_t
791 sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
792 {
793 union perf_mem_data_src data_src_l;
794 union perf_mem_data_src data_src_r;
795
796 if (left->mem_info)
797 data_src_l = left->mem_info->data_src;
798 else
799 data_src_l.mem_lvl = PERF_MEM_LVL_NA;
800
801 if (right->mem_info)
802 data_src_r = right->mem_info->data_src;
803 else
804 data_src_r.mem_lvl = PERF_MEM_LVL_NA;
805
806 return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
807 }
808
809 static const char * const mem_lvl[] = {
810 "N/A",
811 "HIT",
812 "MISS",
813 "L1",
814 "LFB",
815 "L2",
816 "L3",
817 "Local RAM",
818 "Remote RAM (1 hop)",
819 "Remote RAM (2 hops)",
820 "Remote Cache (1 hop)",
821 "Remote Cache (2 hops)",
822 "I/O",
823 "Uncached",
824 };
825 #define NUM_MEM_LVL (sizeof(mem_lvl)/sizeof(const char *))
826
827 static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf,
828 size_t size, unsigned int width)
829 {
830 char out[64];
831 size_t sz = sizeof(out) - 1; /* -1 for null termination */
832 size_t i, l = 0;
833 u64 m = PERF_MEM_LVL_NA;
834 u64 hit, miss;
835
836 if (he->mem_info)
837 m = he->mem_info->data_src.mem_lvl;
838
839 out[0] = '\0';
840
841 hit = m & PERF_MEM_LVL_HIT;
842 miss = m & PERF_MEM_LVL_MISS;
843
844 /* already taken care of */
845 m &= ~(PERF_MEM_LVL_HIT|PERF_MEM_LVL_MISS);
846
847 for (i = 0; m && i < NUM_MEM_LVL; i++, m >>= 1) {
848 if (!(m & 0x1))
849 continue;
850 if (l) {
851 strcat(out, " or ");
852 l += 4;
853 }
854 strncat(out, mem_lvl[i], sz - l);
855 l += strlen(mem_lvl[i]);
856 }
857 if (*out == '\0')
858 strcpy(out, "N/A");
859 if (hit)
860 strncat(out, " hit", sz - l);
861 if (miss)
862 strncat(out, " miss", sz - l);
863
864 return repsep_snprintf(bf, size, "%-*s", width, out);
865 }
866
867 static int64_t
868 sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
869 {
870 union perf_mem_data_src data_src_l;
871 union perf_mem_data_src data_src_r;
872
873 if (left->mem_info)
874 data_src_l = left->mem_info->data_src;
875 else
876 data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
877
878 if (right->mem_info)
879 data_src_r = right->mem_info->data_src;
880 else
881 data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
882
883 return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
884 }
885
886 static const char * const snoop_access[] = {
887 "N/A",
888 "None",
889 "Miss",
890 "Hit",
891 "HitM",
892 };
893 #define NUM_SNOOP_ACCESS (sizeof(snoop_access)/sizeof(const char *))
894
895 static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
896 size_t size, unsigned int width)
897 {
898 char out[64];
899 size_t sz = sizeof(out) - 1; /* -1 for null termination */
900 size_t i, l = 0;
901 u64 m = PERF_MEM_SNOOP_NA;
902
903 out[0] = '\0';
904
905 if (he->mem_info)
906 m = he->mem_info->data_src.mem_snoop;
907
908 for (i = 0; m && i < NUM_SNOOP_ACCESS; i++, m >>= 1) {
909 if (!(m & 0x1))
910 continue;
911 if (l) {
912 strcat(out, " or ");
913 l += 4;
914 }
915 strncat(out, snoop_access[i], sz - l);
916 l += strlen(snoop_access[i]);
917 }
918
919 if (*out == '\0')
920 strcpy(out, "N/A");
921
922 return repsep_snprintf(bf, size, "%-*s", width, out);
923 }
924
925 static inline u64 cl_address(u64 address)
926 {
927 /* return the cacheline of the address */
928 return (address & ~(cacheline_size - 1));
929 }
930
931 static int64_t
932 sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
933 {
934 u64 l, r;
935 struct map *l_map, *r_map;
936
937 if (!left->mem_info) return -1;
938 if (!right->mem_info) return 1;
939
940 /* group event types together */
941 if (left->cpumode > right->cpumode) return -1;
942 if (left->cpumode < right->cpumode) return 1;
943
944 l_map = left->mem_info->daddr.map;
945 r_map = right->mem_info->daddr.map;
946
947 /* if both are NULL, jump to sort on al_addr instead */
948 if (!l_map && !r_map)
949 goto addr;
950
951 if (!l_map) return -1;
952 if (!r_map) return 1;
953
954 if (l_map->maj > r_map->maj) return -1;
955 if (l_map->maj < r_map->maj) return 1;
956
957 if (l_map->min > r_map->min) return -1;
958 if (l_map->min < r_map->min) return 1;
959
960 if (l_map->ino > r_map->ino) return -1;
961 if (l_map->ino < r_map->ino) return 1;
962
963 if (l_map->ino_generation > r_map->ino_generation) return -1;
964 if (l_map->ino_generation < r_map->ino_generation) return 1;
965
966 /*
967 * Addresses with no major/minor numbers are assumed to be
968 * anonymous in userspace. Sort those on pid then address.
969 *
970 * The kernel and non-zero major/minor mapped areas are
971 * assumed to be unity mapped. Sort those on address.
972 */
973
974 if ((left->cpumode != PERF_RECORD_MISC_KERNEL) &&
975 (!(l_map->flags & MAP_SHARED)) &&
976 !l_map->maj && !l_map->min && !l_map->ino &&
977 !l_map->ino_generation) {
978 /* userspace anonymous */
979
980 if (left->thread->pid_ > right->thread->pid_) return -1;
981 if (left->thread->pid_ < right->thread->pid_) return 1;
982 }
983
984 addr:
985 /* al_addr does all the right addr - start + offset calculations */
986 l = cl_address(left->mem_info->daddr.al_addr);
987 r = cl_address(right->mem_info->daddr.al_addr);
988
989 if (l > r) return -1;
990 if (l < r) return 1;
991
992 return 0;
993 }
994
995 static int hist_entry__dcacheline_snprintf(struct hist_entry *he, char *bf,
996 size_t size, unsigned int width)
997 {
998
999 uint64_t addr = 0;
1000 struct map *map = NULL;
1001 struct symbol *sym = NULL;
1002 char level = he->level;
1003
1004 if (he->mem_info) {
1005 addr = cl_address(he->mem_info->daddr.al_addr);
1006 map = he->mem_info->daddr.map;
1007 sym = he->mem_info->daddr.sym;
1008
1009 /* print [s] for shared data mmaps */
1010 if ((he->cpumode != PERF_RECORD_MISC_KERNEL) &&
1011 map && (map->type == MAP__VARIABLE) &&
1012 (map->flags & MAP_SHARED) &&
1013 (map->maj || map->min || map->ino ||
1014 map->ino_generation))
1015 level = 's';
1016 else if (!map)
1017 level = 'X';
1018 }
1019 return _hist_entry__sym_snprintf(map, sym, addr, level, bf, size,
1020 width);
1021 }
1022
1023 struct sort_entry sort_mispredict = {
1024 .se_header = "Branch Mispredicted",
1025 .se_cmp = sort__mispredict_cmp,
1026 .se_snprintf = hist_entry__mispredict_snprintf,
1027 .se_width_idx = HISTC_MISPREDICT,
1028 };
1029
1030 static u64 he_weight(struct hist_entry *he)
1031 {
1032 return he->stat.nr_events ? he->stat.weight / he->stat.nr_events : 0;
1033 }
1034
1035 static int64_t
1036 sort__local_weight_cmp(struct hist_entry *left, struct hist_entry *right)
1037 {
1038 return he_weight(left) - he_weight(right);
1039 }
1040
1041 static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf,
1042 size_t size, unsigned int width)
1043 {
1044 return repsep_snprintf(bf, size, "%-*llu", width, he_weight(he));
1045 }
1046
1047 struct sort_entry sort_local_weight = {
1048 .se_header = "Local Weight",
1049 .se_cmp = sort__local_weight_cmp,
1050 .se_snprintf = hist_entry__local_weight_snprintf,
1051 .se_width_idx = HISTC_LOCAL_WEIGHT,
1052 };
1053
1054 static int64_t
1055 sort__global_weight_cmp(struct hist_entry *left, struct hist_entry *right)
1056 {
1057 return left->stat.weight - right->stat.weight;
1058 }
1059
1060 static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf,
1061 size_t size, unsigned int width)
1062 {
1063 return repsep_snprintf(bf, size, "%-*llu", width, he->stat.weight);
1064 }
1065
1066 struct sort_entry sort_global_weight = {
1067 .se_header = "Weight",
1068 .se_cmp = sort__global_weight_cmp,
1069 .se_snprintf = hist_entry__global_weight_snprintf,
1070 .se_width_idx = HISTC_GLOBAL_WEIGHT,
1071 };
1072
1073 struct sort_entry sort_mem_daddr_sym = {
1074 .se_header = "Data Symbol",
1075 .se_cmp = sort__daddr_cmp,
1076 .se_snprintf = hist_entry__daddr_snprintf,
1077 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
1078 };
1079
1080 struct sort_entry sort_mem_daddr_dso = {
1081 .se_header = "Data Object",
1082 .se_cmp = sort__dso_daddr_cmp,
1083 .se_snprintf = hist_entry__dso_daddr_snprintf,
1084 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
1085 };
1086
1087 struct sort_entry sort_mem_locked = {
1088 .se_header = "Locked",
1089 .se_cmp = sort__locked_cmp,
1090 .se_snprintf = hist_entry__locked_snprintf,
1091 .se_width_idx = HISTC_MEM_LOCKED,
1092 };
1093
1094 struct sort_entry sort_mem_tlb = {
1095 .se_header = "TLB access",
1096 .se_cmp = sort__tlb_cmp,
1097 .se_snprintf = hist_entry__tlb_snprintf,
1098 .se_width_idx = HISTC_MEM_TLB,
1099 };
1100
1101 struct sort_entry sort_mem_lvl = {
1102 .se_header = "Memory access",
1103 .se_cmp = sort__lvl_cmp,
1104 .se_snprintf = hist_entry__lvl_snprintf,
1105 .se_width_idx = HISTC_MEM_LVL,
1106 };
1107
1108 struct sort_entry sort_mem_snoop = {
1109 .se_header = "Snoop",
1110 .se_cmp = sort__snoop_cmp,
1111 .se_snprintf = hist_entry__snoop_snprintf,
1112 .se_width_idx = HISTC_MEM_SNOOP,
1113 };
1114
1115 struct sort_entry sort_mem_dcacheline = {
1116 .se_header = "Data Cacheline",
1117 .se_cmp = sort__dcacheline_cmp,
1118 .se_snprintf = hist_entry__dcacheline_snprintf,
1119 .se_width_idx = HISTC_MEM_DCACHELINE,
1120 };
1121
1122 static int64_t
1123 sort__abort_cmp(struct hist_entry *left, struct hist_entry *right)
1124 {
1125 if (!left->branch_info || !right->branch_info)
1126 return cmp_null(left->branch_info, right->branch_info);
1127
1128 return left->branch_info->flags.abort !=
1129 right->branch_info->flags.abort;
1130 }
1131
1132 static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf,
1133 size_t size, unsigned int width)
1134 {
1135 static const char *out = "N/A";
1136
1137 if (he->branch_info) {
1138 if (he->branch_info->flags.abort)
1139 out = "A";
1140 else
1141 out = ".";
1142 }
1143
1144 return repsep_snprintf(bf, size, "%-*s", width, out);
1145 }
1146
1147 struct sort_entry sort_abort = {
1148 .se_header = "Transaction abort",
1149 .se_cmp = sort__abort_cmp,
1150 .se_snprintf = hist_entry__abort_snprintf,
1151 .se_width_idx = HISTC_ABORT,
1152 };
1153
1154 static int64_t
1155 sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
1156 {
1157 if (!left->branch_info || !right->branch_info)
1158 return cmp_null(left->branch_info, right->branch_info);
1159
1160 return left->branch_info->flags.in_tx !=
1161 right->branch_info->flags.in_tx;
1162 }
1163
1164 static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf,
1165 size_t size, unsigned int width)
1166 {
1167 static const char *out = "N/A";
1168
1169 if (he->branch_info) {
1170 if (he->branch_info->flags.in_tx)
1171 out = "T";
1172 else
1173 out = ".";
1174 }
1175
1176 return repsep_snprintf(bf, size, "%-*s", width, out);
1177 }
1178
1179 struct sort_entry sort_in_tx = {
1180 .se_header = "Branch in transaction",
1181 .se_cmp = sort__in_tx_cmp,
1182 .se_snprintf = hist_entry__in_tx_snprintf,
1183 .se_width_idx = HISTC_IN_TX,
1184 };
1185
1186 static int64_t
1187 sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right)
1188 {
1189 return left->transaction - right->transaction;
1190 }
1191
1192 static inline char *add_str(char *p, const char *str)
1193 {
1194 strcpy(p, str);
1195 return p + strlen(str);
1196 }
1197
1198 static struct txbit {
1199 unsigned flag;
1200 const char *name;
1201 int skip_for_len;
1202 } txbits[] = {
1203 { PERF_TXN_ELISION, "EL ", 0 },
1204 { PERF_TXN_TRANSACTION, "TX ", 1 },
1205 { PERF_TXN_SYNC, "SYNC ", 1 },
1206 { PERF_TXN_ASYNC, "ASYNC ", 0 },
1207 { PERF_TXN_RETRY, "RETRY ", 0 },
1208 { PERF_TXN_CONFLICT, "CON ", 0 },
1209 { PERF_TXN_CAPACITY_WRITE, "CAP-WRITE ", 1 },
1210 { PERF_TXN_CAPACITY_READ, "CAP-READ ", 0 },
1211 { 0, NULL, 0 }
1212 };
1213
1214 int hist_entry__transaction_len(void)
1215 {
1216 int i;
1217 int len = 0;
1218
1219 for (i = 0; txbits[i].name; i++) {
1220 if (!txbits[i].skip_for_len)
1221 len += strlen(txbits[i].name);
1222 }
1223 len += 4; /* :XX<space> */
1224 return len;
1225 }
1226
1227 static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf,
1228 size_t size, unsigned int width)
1229 {
1230 u64 t = he->transaction;
1231 char buf[128];
1232 char *p = buf;
1233 int i;
1234
1235 buf[0] = 0;
1236 for (i = 0; txbits[i].name; i++)
1237 if (txbits[i].flag & t)
1238 p = add_str(p, txbits[i].name);
1239 if (t && !(t & (PERF_TXN_SYNC|PERF_TXN_ASYNC)))
1240 p = add_str(p, "NEITHER ");
1241 if (t & PERF_TXN_ABORT_MASK) {
1242 sprintf(p, ":%" PRIx64,
1243 (t & PERF_TXN_ABORT_MASK) >>
1244 PERF_TXN_ABORT_SHIFT);
1245 p += strlen(p);
1246 }
1247
1248 return repsep_snprintf(bf, size, "%-*s", width, buf);
1249 }
1250
1251 struct sort_entry sort_transaction = {
1252 .se_header = "Transaction ",
1253 .se_cmp = sort__transaction_cmp,
1254 .se_snprintf = hist_entry__transaction_snprintf,
1255 .se_width_idx = HISTC_TRANSACTION,
1256 };
1257
1258 struct sort_dimension {
1259 const char *name;
1260 struct sort_entry *entry;
1261 int taken;
1262 };
1263
1264 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
1265
1266 static struct sort_dimension common_sort_dimensions[] = {
1267 DIM(SORT_PID, "pid", sort_thread),
1268 DIM(SORT_COMM, "comm", sort_comm),
1269 DIM(SORT_DSO, "dso", sort_dso),
1270 DIM(SORT_SYM, "symbol", sort_sym),
1271 DIM(SORT_PARENT, "parent", sort_parent),
1272 DIM(SORT_CPU, "cpu", sort_cpu),
1273 DIM(SORT_SOCKET, "socket", sort_socket),
1274 DIM(SORT_SRCLINE, "srcline", sort_srcline),
1275 DIM(SORT_SRCFILE, "srcfile", sort_srcfile),
1276 DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
1277 DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
1278 DIM(SORT_TRANSACTION, "transaction", sort_transaction),
1279 };
1280
1281 #undef DIM
1282
1283 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
1284
1285 static struct sort_dimension bstack_sort_dimensions[] = {
1286 DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
1287 DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
1288 DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
1289 DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
1290 DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
1291 DIM(SORT_IN_TX, "in_tx", sort_in_tx),
1292 DIM(SORT_ABORT, "abort", sort_abort),
1293 DIM(SORT_CYCLES, "cycles", sort_cycles),
1294 };
1295
1296 #undef DIM
1297
1298 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
1299
1300 static struct sort_dimension memory_sort_dimensions[] = {
1301 DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
1302 DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
1303 DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
1304 DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
1305 DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
1306 DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
1307 DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline),
1308 };
1309
1310 #undef DIM
1311
1312 struct hpp_dimension {
1313 const char *name;
1314 struct perf_hpp_fmt *fmt;
1315 int taken;
1316 };
1317
1318 #define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], }
1319
1320 static struct hpp_dimension hpp_sort_dimensions[] = {
1321 DIM(PERF_HPP__OVERHEAD, "overhead"),
1322 DIM(PERF_HPP__OVERHEAD_SYS, "overhead_sys"),
1323 DIM(PERF_HPP__OVERHEAD_US, "overhead_us"),
1324 DIM(PERF_HPP__OVERHEAD_GUEST_SYS, "overhead_guest_sys"),
1325 DIM(PERF_HPP__OVERHEAD_GUEST_US, "overhead_guest_us"),
1326 DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"),
1327 DIM(PERF_HPP__SAMPLES, "sample"),
1328 DIM(PERF_HPP__PERIOD, "period"),
1329 };
1330
1331 #undef DIM
1332
1333 struct hpp_sort_entry {
1334 struct perf_hpp_fmt hpp;
1335 struct sort_entry *se;
1336 };
1337
1338 bool perf_hpp__same_sort_entry(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
1339 {
1340 struct hpp_sort_entry *hse_a;
1341 struct hpp_sort_entry *hse_b;
1342
1343 if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b))
1344 return false;
1345
1346 hse_a = container_of(a, struct hpp_sort_entry, hpp);
1347 hse_b = container_of(b, struct hpp_sort_entry, hpp);
1348
1349 return hse_a->se == hse_b->se;
1350 }
1351
1352 void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
1353 {
1354 struct hpp_sort_entry *hse;
1355
1356 if (!perf_hpp__is_sort_entry(fmt))
1357 return;
1358
1359 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1360 hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
1361 }
1362
1363 static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1364 struct perf_evsel *evsel)
1365 {
1366 struct hpp_sort_entry *hse;
1367 size_t len = fmt->user_len;
1368
1369 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1370
1371 if (!len)
1372 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1373
1374 return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
1375 }
1376
1377 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
1378 struct perf_hpp *hpp __maybe_unused,
1379 struct perf_evsel *evsel)
1380 {
1381 struct hpp_sort_entry *hse;
1382 size_t len = fmt->user_len;
1383
1384 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1385
1386 if (!len)
1387 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1388
1389 return len;
1390 }
1391
1392 static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1393 struct hist_entry *he)
1394 {
1395 struct hpp_sort_entry *hse;
1396 size_t len = fmt->user_len;
1397
1398 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1399
1400 if (!len)
1401 len = hists__col_len(he->hists, hse->se->se_width_idx);
1402
1403 return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
1404 }
1405
1406 static int64_t __sort__hpp_cmp(struct perf_hpp_fmt *fmt,
1407 struct hist_entry *a, struct hist_entry *b)
1408 {
1409 struct hpp_sort_entry *hse;
1410
1411 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1412 return hse->se->se_cmp(a, b);
1413 }
1414
1415 static int64_t __sort__hpp_collapse(struct perf_hpp_fmt *fmt,
1416 struct hist_entry *a, struct hist_entry *b)
1417 {
1418 struct hpp_sort_entry *hse;
1419 int64_t (*collapse_fn)(struct hist_entry *, struct hist_entry *);
1420
1421 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1422 collapse_fn = hse->se->se_collapse ?: hse->se->se_cmp;
1423 return collapse_fn(a, b);
1424 }
1425
1426 static int64_t __sort__hpp_sort(struct perf_hpp_fmt *fmt,
1427 struct hist_entry *a, struct hist_entry *b)
1428 {
1429 struct hpp_sort_entry *hse;
1430 int64_t (*sort_fn)(struct hist_entry *, struct hist_entry *);
1431
1432 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1433 sort_fn = hse->se->se_sort ?: hse->se->se_cmp;
1434 return sort_fn(a, b);
1435 }
1436
1437 static struct hpp_sort_entry *
1438 __sort_dimension__alloc_hpp(struct sort_dimension *sd)
1439 {
1440 struct hpp_sort_entry *hse;
1441
1442 hse = malloc(sizeof(*hse));
1443 if (hse == NULL) {
1444 pr_err("Memory allocation failed\n");
1445 return NULL;
1446 }
1447
1448 hse->se = sd->entry;
1449 hse->hpp.name = sd->entry->se_header;
1450 hse->hpp.header = __sort__hpp_header;
1451 hse->hpp.width = __sort__hpp_width;
1452 hse->hpp.entry = __sort__hpp_entry;
1453 hse->hpp.color = NULL;
1454
1455 hse->hpp.cmp = __sort__hpp_cmp;
1456 hse->hpp.collapse = __sort__hpp_collapse;
1457 hse->hpp.sort = __sort__hpp_sort;
1458
1459 INIT_LIST_HEAD(&hse->hpp.list);
1460 INIT_LIST_HEAD(&hse->hpp.sort_list);
1461 hse->hpp.elide = false;
1462 hse->hpp.len = 0;
1463 hse->hpp.user_len = 0;
1464
1465 return hse;
1466 }
1467
1468 bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)
1469 {
1470 return format->header == __sort__hpp_header;
1471 }
1472
1473 static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd)
1474 {
1475 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1476
1477 if (hse == NULL)
1478 return -1;
1479
1480 perf_hpp__register_sort_field(&hse->hpp);
1481 return 0;
1482 }
1483
1484 static int __sort_dimension__add_hpp_output(struct sort_dimension *sd)
1485 {
1486 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1487
1488 if (hse == NULL)
1489 return -1;
1490
1491 perf_hpp__column_register(&hse->hpp);
1492 return 0;
1493 }
1494
1495 static int __sort_dimension__add(struct sort_dimension *sd)
1496 {
1497 if (sd->taken)
1498 return 0;
1499
1500 if (__sort_dimension__add_hpp_sort(sd) < 0)
1501 return -1;
1502
1503 if (sd->entry->se_collapse)
1504 sort__need_collapse = 1;
1505
1506 sd->taken = 1;
1507
1508 return 0;
1509 }
1510
1511 static int __hpp_dimension__add(struct hpp_dimension *hd)
1512 {
1513 if (!hd->taken) {
1514 hd->taken = 1;
1515
1516 perf_hpp__register_sort_field(hd->fmt);
1517 }
1518 return 0;
1519 }
1520
1521 static int __sort_dimension__add_output(struct sort_dimension *sd)
1522 {
1523 if (sd->taken)
1524 return 0;
1525
1526 if (__sort_dimension__add_hpp_output(sd) < 0)
1527 return -1;
1528
1529 sd->taken = 1;
1530 return 0;
1531 }
1532
1533 static int __hpp_dimension__add_output(struct hpp_dimension *hd)
1534 {
1535 if (!hd->taken) {
1536 hd->taken = 1;
1537
1538 perf_hpp__column_register(hd->fmt);
1539 }
1540 return 0;
1541 }
1542
1543 int sort_dimension__add(const char *tok)
1544 {
1545 unsigned int i;
1546
1547 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
1548 struct sort_dimension *sd = &common_sort_dimensions[i];
1549
1550 if (strncasecmp(tok, sd->name, strlen(tok)))
1551 continue;
1552
1553 if (sd->entry == &sort_parent) {
1554 int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
1555 if (ret) {
1556 char err[BUFSIZ];
1557
1558 regerror(ret, &parent_regex, err, sizeof(err));
1559 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
1560 return -EINVAL;
1561 }
1562 sort__has_parent = 1;
1563 } else if (sd->entry == &sort_sym) {
1564 sort__has_sym = 1;
1565 /*
1566 * perf diff displays the performance difference amongst
1567 * two or more perf.data files. Those files could come
1568 * from different binaries. So we should not compare
1569 * their ips, but the name of symbol.
1570 */
1571 if (sort__mode == SORT_MODE__DIFF)
1572 sd->entry->se_collapse = sort__sym_sort;
1573
1574 } else if (sd->entry == &sort_dso) {
1575 sort__has_dso = 1;
1576 } else if (sd->entry == &sort_socket) {
1577 sort__has_socket = 1;
1578 }
1579
1580 return __sort_dimension__add(sd);
1581 }
1582
1583 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
1584 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
1585
1586 if (strncasecmp(tok, hd->name, strlen(tok)))
1587 continue;
1588
1589 return __hpp_dimension__add(hd);
1590 }
1591
1592 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
1593 struct sort_dimension *sd = &bstack_sort_dimensions[i];
1594
1595 if (strncasecmp(tok, sd->name, strlen(tok)))
1596 continue;
1597
1598 if (sort__mode != SORT_MODE__BRANCH)
1599 return -EINVAL;
1600
1601 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
1602 sort__has_sym = 1;
1603
1604 __sort_dimension__add(sd);
1605 return 0;
1606 }
1607
1608 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
1609 struct sort_dimension *sd = &memory_sort_dimensions[i];
1610
1611 if (strncasecmp(tok, sd->name, strlen(tok)))
1612 continue;
1613
1614 if (sort__mode != SORT_MODE__MEMORY)
1615 return -EINVAL;
1616
1617 if (sd->entry == &sort_mem_daddr_sym)
1618 sort__has_sym = 1;
1619
1620 __sort_dimension__add(sd);
1621 return 0;
1622 }
1623
1624 return -ESRCH;
1625 }
1626
1627 static const char *get_default_sort_order(void)
1628 {
1629 const char *default_sort_orders[] = {
1630 default_sort_order,
1631 default_branch_sort_order,
1632 default_mem_sort_order,
1633 default_top_sort_order,
1634 default_diff_sort_order,
1635 };
1636
1637 BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders));
1638
1639 return default_sort_orders[sort__mode];
1640 }
1641
1642 static int setup_sort_order(void)
1643 {
1644 char *new_sort_order;
1645
1646 /*
1647 * Append '+'-prefixed sort order to the default sort
1648 * order string.
1649 */
1650 if (!sort_order || is_strict_order(sort_order))
1651 return 0;
1652
1653 if (sort_order[1] == '\0') {
1654 error("Invalid --sort key: `+'");
1655 return -EINVAL;
1656 }
1657
1658 /*
1659 * We allocate new sort_order string, but we never free it,
1660 * because it's checked over the rest of the code.
1661 */
1662 if (asprintf(&new_sort_order, "%s,%s",
1663 get_default_sort_order(), sort_order + 1) < 0) {
1664 error("Not enough memory to set up --sort");
1665 return -ENOMEM;
1666 }
1667
1668 sort_order = new_sort_order;
1669 return 0;
1670 }
1671
1672 static int __setup_sorting(void)
1673 {
1674 char *tmp, *tok, *str;
1675 const char *sort_keys;
1676 int ret = 0;
1677
1678 ret = setup_sort_order();
1679 if (ret)
1680 return ret;
1681
1682 sort_keys = sort_order;
1683 if (sort_keys == NULL) {
1684 if (is_strict_order(field_order)) {
1685 /*
1686 * If user specified field order but no sort order,
1687 * we'll honor it and not add default sort orders.
1688 */
1689 return 0;
1690 }
1691
1692 sort_keys = get_default_sort_order();
1693 }
1694
1695 str = strdup(sort_keys);
1696 if (str == NULL) {
1697 error("Not enough memory to setup sort keys");
1698 return -ENOMEM;
1699 }
1700
1701 for (tok = strtok_r(str, ", ", &tmp);
1702 tok; tok = strtok_r(NULL, ", ", &tmp)) {
1703 ret = sort_dimension__add(tok);
1704 if (ret == -EINVAL) {
1705 error("Invalid --sort key: `%s'", tok);
1706 break;
1707 } else if (ret == -ESRCH) {
1708 error("Unknown --sort key: `%s'", tok);
1709 break;
1710 }
1711 }
1712
1713 free(str);
1714 return ret;
1715 }
1716
1717 void perf_hpp__set_elide(int idx, bool elide)
1718 {
1719 struct perf_hpp_fmt *fmt;
1720 struct hpp_sort_entry *hse;
1721
1722 perf_hpp__for_each_format(fmt) {
1723 if (!perf_hpp__is_sort_entry(fmt))
1724 continue;
1725
1726 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1727 if (hse->se->se_width_idx == idx) {
1728 fmt->elide = elide;
1729 break;
1730 }
1731 }
1732 }
1733
1734 static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp)
1735 {
1736 if (list && strlist__nr_entries(list) == 1) {
1737 if (fp != NULL)
1738 fprintf(fp, "# %s: %s\n", list_name,
1739 strlist__entry(list, 0)->s);
1740 return true;
1741 }
1742 return false;
1743 }
1744
1745 static bool get_elide(int idx, FILE *output)
1746 {
1747 switch (idx) {
1748 case HISTC_SYMBOL:
1749 return __get_elide(symbol_conf.sym_list, "symbol", output);
1750 case HISTC_DSO:
1751 return __get_elide(symbol_conf.dso_list, "dso", output);
1752 case HISTC_COMM:
1753 return __get_elide(symbol_conf.comm_list, "comm", output);
1754 default:
1755 break;
1756 }
1757
1758 if (sort__mode != SORT_MODE__BRANCH)
1759 return false;
1760
1761 switch (idx) {
1762 case HISTC_SYMBOL_FROM:
1763 return __get_elide(symbol_conf.sym_from_list, "sym_from", output);
1764 case HISTC_SYMBOL_TO:
1765 return __get_elide(symbol_conf.sym_to_list, "sym_to", output);
1766 case HISTC_DSO_FROM:
1767 return __get_elide(symbol_conf.dso_from_list, "dso_from", output);
1768 case HISTC_DSO_TO:
1769 return __get_elide(symbol_conf.dso_to_list, "dso_to", output);
1770 default:
1771 break;
1772 }
1773
1774 return false;
1775 }
1776
1777 void sort__setup_elide(FILE *output)
1778 {
1779 struct perf_hpp_fmt *fmt;
1780 struct hpp_sort_entry *hse;
1781
1782 perf_hpp__for_each_format(fmt) {
1783 if (!perf_hpp__is_sort_entry(fmt))
1784 continue;
1785
1786 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1787 fmt->elide = get_elide(hse->se->se_width_idx, output);
1788 }
1789
1790 /*
1791 * It makes no sense to elide all of sort entries.
1792 * Just revert them to show up again.
1793 */
1794 perf_hpp__for_each_format(fmt) {
1795 if (!perf_hpp__is_sort_entry(fmt))
1796 continue;
1797
1798 if (!fmt->elide)
1799 return;
1800 }
1801
1802 perf_hpp__for_each_format(fmt) {
1803 if (!perf_hpp__is_sort_entry(fmt))
1804 continue;
1805
1806 fmt->elide = false;
1807 }
1808 }
1809
1810 static int output_field_add(char *tok)
1811 {
1812 unsigned int i;
1813
1814 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
1815 struct sort_dimension *sd = &common_sort_dimensions[i];
1816
1817 if (strncasecmp(tok, sd->name, strlen(tok)))
1818 continue;
1819
1820 return __sort_dimension__add_output(sd);
1821 }
1822
1823 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
1824 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
1825
1826 if (strncasecmp(tok, hd->name, strlen(tok)))
1827 continue;
1828
1829 return __hpp_dimension__add_output(hd);
1830 }
1831
1832 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
1833 struct sort_dimension *sd = &bstack_sort_dimensions[i];
1834
1835 if (strncasecmp(tok, sd->name, strlen(tok)))
1836 continue;
1837
1838 return __sort_dimension__add_output(sd);
1839 }
1840
1841 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
1842 struct sort_dimension *sd = &memory_sort_dimensions[i];
1843
1844 if (strncasecmp(tok, sd->name, strlen(tok)))
1845 continue;
1846
1847 return __sort_dimension__add_output(sd);
1848 }
1849
1850 return -ESRCH;
1851 }
1852
1853 static void reset_dimensions(void)
1854 {
1855 unsigned int i;
1856
1857 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++)
1858 common_sort_dimensions[i].taken = 0;
1859
1860 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++)
1861 hpp_sort_dimensions[i].taken = 0;
1862
1863 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++)
1864 bstack_sort_dimensions[i].taken = 0;
1865
1866 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++)
1867 memory_sort_dimensions[i].taken = 0;
1868 }
1869
1870 bool is_strict_order(const char *order)
1871 {
1872 return order && (*order != '+');
1873 }
1874
1875 static int __setup_output_field(void)
1876 {
1877 char *tmp, *tok, *str, *strp;
1878 int ret = -EINVAL;
1879
1880 if (field_order == NULL)
1881 return 0;
1882
1883 reset_dimensions();
1884
1885 strp = str = strdup(field_order);
1886 if (str == NULL) {
1887 error("Not enough memory to setup output fields");
1888 return -ENOMEM;
1889 }
1890
1891 if (!is_strict_order(field_order))
1892 strp++;
1893
1894 if (!strlen(strp)) {
1895 error("Invalid --fields key: `+'");
1896 goto out;
1897 }
1898
1899 for (tok = strtok_r(strp, ", ", &tmp);
1900 tok; tok = strtok_r(NULL, ", ", &tmp)) {
1901 ret = output_field_add(tok);
1902 if (ret == -EINVAL) {
1903 error("Invalid --fields key: `%s'", tok);
1904 break;
1905 } else if (ret == -ESRCH) {
1906 error("Unknown --fields key: `%s'", tok);
1907 break;
1908 }
1909 }
1910
1911 out:
1912 free(str);
1913 return ret;
1914 }
1915
1916 int setup_sorting(void)
1917 {
1918 int err;
1919
1920 err = __setup_sorting();
1921 if (err < 0)
1922 return err;
1923
1924 if (parent_pattern != default_parent_pattern) {
1925 err = sort_dimension__add("parent");
1926 if (err < 0)
1927 return err;
1928 }
1929
1930 reset_dimensions();
1931
1932 /*
1933 * perf diff doesn't use default hpp output fields.
1934 */
1935 if (sort__mode != SORT_MODE__DIFF)
1936 perf_hpp__init();
1937
1938 err = __setup_output_field();
1939 if (err < 0)
1940 return err;
1941
1942 /* copy sort keys to output fields */
1943 perf_hpp__setup_output_field();
1944 /* and then copy output fields to sort keys */
1945 perf_hpp__append_sort_keys();
1946
1947 return 0;
1948 }
1949
1950 void reset_output_field(void)
1951 {
1952 sort__need_collapse = 0;
1953 sort__has_parent = 0;
1954 sort__has_sym = 0;
1955 sort__has_dso = 0;
1956
1957 field_order = NULL;
1958 sort_order = NULL;
1959
1960 reset_dimensions();
1961 perf_hpp__reset_output_field();
1962 }
Linux kernel - Deliverables
This page took 0.096046 seconds and 6 git commands to generate.