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