?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ceph: use i_size_{read,write} to get/set i_size
[linux/fpc-iii.git] / tools / perf / util / sort.c
blob2d8ccd4d9e1b7bd5231d35c2afaaec9078c86573
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__iaddr_cmp(struct hist_entry *left, struct hist_entry *right)
659 {
660 uint64_t l = 0, r = 0;
661
662 if (left->mem_info)
663 l = left->mem_info->iaddr.addr;
664 if (right->mem_info)
665 r = right->mem_info->iaddr.addr;
666
667 return (int64_t)(r - l);
668 }
669
670 static int hist_entry__iaddr_snprintf(struct hist_entry *he, char *bf,
671 size_t size, unsigned int width)
672 {
673 uint64_t addr = 0;
674 struct map *map = NULL;
675 struct symbol *sym = NULL;
676
677 if (he->mem_info) {
678 addr = he->mem_info->iaddr.addr;
679 map = he->mem_info->iaddr.map;
680 sym = he->mem_info->iaddr.sym;
681 }
682 return _hist_entry__sym_snprintf(map, sym, addr, he->level, bf, size,
683 width);
684 }
685
686 static int64_t
687 sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
688 {
689 struct map *map_l = NULL;
690 struct map *map_r = NULL;
691
692 if (left->mem_info)
693 map_l = left->mem_info->daddr.map;
694 if (right->mem_info)
695 map_r = right->mem_info->daddr.map;
696
697 return _sort__dso_cmp(map_l, map_r);
698 }
699
700 static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf,
701 size_t size, unsigned int width)
702 {
703 struct map *map = NULL;
704
705 if (he->mem_info)
706 map = he->mem_info->daddr.map;
707
708 return _hist_entry__dso_snprintf(map, bf, size, width);
709 }
710
711 static int64_t
712 sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
713 {
714 union perf_mem_data_src data_src_l;
715 union perf_mem_data_src data_src_r;
716
717 if (left->mem_info)
718 data_src_l = left->mem_info->data_src;
719 else
720 data_src_l.mem_lock = PERF_MEM_LOCK_NA;
721
722 if (right->mem_info)
723 data_src_r = right->mem_info->data_src;
724 else
725 data_src_r.mem_lock = PERF_MEM_LOCK_NA;
726
727 return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
728 }
729
730 static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf,
731 size_t size, unsigned int width)
732 {
733 const char *out;
734 u64 mask = PERF_MEM_LOCK_NA;
735
736 if (he->mem_info)
737 mask = he->mem_info->data_src.mem_lock;
738
739 if (mask & PERF_MEM_LOCK_NA)
740 out = "N/A";
741 else if (mask & PERF_MEM_LOCK_LOCKED)
742 out = "Yes";
743 else
744 out = "No";
745
746 return repsep_snprintf(bf, size, "%-*s", width, out);
747 }
748
749 static int64_t
750 sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
751 {
752 union perf_mem_data_src data_src_l;
753 union perf_mem_data_src data_src_r;
754
755 if (left->mem_info)
756 data_src_l = left->mem_info->data_src;
757 else
758 data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
759
760 if (right->mem_info)
761 data_src_r = right->mem_info->data_src;
762 else
763 data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
764
765 return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
766 }
767
768 static const char * const tlb_access[] = {
769 "N/A",
770 "HIT",
771 "MISS",
772 "L1",
773 "L2",
774 "Walker",
775 "Fault",
776 };
777 #define NUM_TLB_ACCESS (sizeof(tlb_access)/sizeof(const char *))
778
779 static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf,
780 size_t size, unsigned int width)
781 {
782 char out[64];
783 size_t sz = sizeof(out) - 1; /* -1 for null termination */
784 size_t l = 0, i;
785 u64 m = PERF_MEM_TLB_NA;
786 u64 hit, miss;
787
788 out[0] = '\0';
789
790 if (he->mem_info)
791 m = he->mem_info->data_src.mem_dtlb;
792
793 hit = m & PERF_MEM_TLB_HIT;
794 miss = m & PERF_MEM_TLB_MISS;
795
796 /* already taken care of */
797 m &= ~(PERF_MEM_TLB_HIT|PERF_MEM_TLB_MISS);
798
799 for (i = 0; m && i < NUM_TLB_ACCESS; i++, m >>= 1) {
800 if (!(m & 0x1))
801 continue;
802 if (l) {
803 strcat(out, " or ");
804 l += 4;
805 }
806 strncat(out, tlb_access[i], sz - l);
807 l += strlen(tlb_access[i]);
808 }
809 if (*out == '\0')
810 strcpy(out, "N/A");
811 if (hit)
812 strncat(out, " hit", sz - l);
813 if (miss)
814 strncat(out, " miss", sz - l);
815
816 return repsep_snprintf(bf, size, "%-*s", width, out);
817 }
818
819 static int64_t
820 sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
821 {
822 union perf_mem_data_src data_src_l;
823 union perf_mem_data_src data_src_r;
824
825 if (left->mem_info)
826 data_src_l = left->mem_info->data_src;
827 else
828 data_src_l.mem_lvl = PERF_MEM_LVL_NA;
829
830 if (right->mem_info)
831 data_src_r = right->mem_info->data_src;
832 else
833 data_src_r.mem_lvl = PERF_MEM_LVL_NA;
834
835 return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
836 }
837
838 static const char * const mem_lvl[] = {
839 "N/A",
840 "HIT",
841 "MISS",
842 "L1",
843 "LFB",
844 "L2",
845 "L3",
846 "Local RAM",
847 "Remote RAM (1 hop)",
848 "Remote RAM (2 hops)",
849 "Remote Cache (1 hop)",
850 "Remote Cache (2 hops)",
851 "I/O",
852 "Uncached",
853 };
854 #define NUM_MEM_LVL (sizeof(mem_lvl)/sizeof(const char *))
855
856 static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf,
857 size_t size, unsigned int width)
858 {
859 char out[64];
860 size_t sz = sizeof(out) - 1; /* -1 for null termination */
861 size_t i, l = 0;
862 u64 m = PERF_MEM_LVL_NA;
863 u64 hit, miss;
864
865 if (he->mem_info)
866 m = he->mem_info->data_src.mem_lvl;
867
868 out[0] = '\0';
869
870 hit = m & PERF_MEM_LVL_HIT;
871 miss = m & PERF_MEM_LVL_MISS;
872
873 /* already taken care of */
874 m &= ~(PERF_MEM_LVL_HIT|PERF_MEM_LVL_MISS);
875
876 for (i = 0; m && i < NUM_MEM_LVL; i++, m >>= 1) {
877 if (!(m & 0x1))
878 continue;
879 if (l) {
880 strcat(out, " or ");
881 l += 4;
882 }
883 strncat(out, mem_lvl[i], sz - l);
884 l += strlen(mem_lvl[i]);
885 }
886 if (*out == '\0')
887 strcpy(out, "N/A");
888 if (hit)
889 strncat(out, " hit", sz - l);
890 if (miss)
891 strncat(out, " miss", sz - l);
892
893 return repsep_snprintf(bf, size, "%-*s", width, out);
894 }
895
896 static int64_t
897 sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
898 {
899 union perf_mem_data_src data_src_l;
900 union perf_mem_data_src data_src_r;
901
902 if (left->mem_info)
903 data_src_l = left->mem_info->data_src;
904 else
905 data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
906
907 if (right->mem_info)
908 data_src_r = right->mem_info->data_src;
909 else
910 data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
911
912 return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
913 }
914
915 static const char * const snoop_access[] = {
916 "N/A",
917 "None",
918 "Miss",
919 "Hit",
920 "HitM",
921 };
922 #define NUM_SNOOP_ACCESS (sizeof(snoop_access)/sizeof(const char *))
923
924 static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
925 size_t size, unsigned int width)
926 {
927 char out[64];
928 size_t sz = sizeof(out) - 1; /* -1 for null termination */
929 size_t i, l = 0;
930 u64 m = PERF_MEM_SNOOP_NA;
931
932 out[0] = '\0';
933
934 if (he->mem_info)
935 m = he->mem_info->data_src.mem_snoop;
936
937 for (i = 0; m && i < NUM_SNOOP_ACCESS; i++, m >>= 1) {
938 if (!(m & 0x1))
939 continue;
940 if (l) {
941 strcat(out, " or ");
942 l += 4;
943 }
944 strncat(out, snoop_access[i], sz - l);
945 l += strlen(snoop_access[i]);
946 }
947
948 if (*out == '\0')
949 strcpy(out, "N/A");
950
951 return repsep_snprintf(bf, size, "%-*s", width, out);
952 }
953
954 static inline u64 cl_address(u64 address)
955 {
956 /* return the cacheline of the address */
957 return (address & ~(cacheline_size - 1));
958 }
959
960 static int64_t
961 sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
962 {
963 u64 l, r;
964 struct map *l_map, *r_map;
965
966 if (!left->mem_info) return -1;
967 if (!right->mem_info) return 1;
968
969 /* group event types together */
970 if (left->cpumode > right->cpumode) return -1;
971 if (left->cpumode < right->cpumode) return 1;
972
973 l_map = left->mem_info->daddr.map;
974 r_map = right->mem_info->daddr.map;
975
976 /* if both are NULL, jump to sort on al_addr instead */
977 if (!l_map && !r_map)
978 goto addr;
979
980 if (!l_map) return -1;
981 if (!r_map) return 1;
982
983 if (l_map->maj > r_map->maj) return -1;
984 if (l_map->maj < r_map->maj) return 1;
985
986 if (l_map->min > r_map->min) return -1;
987 if (l_map->min < r_map->min) return 1;
988
989 if (l_map->ino > r_map->ino) return -1;
990 if (l_map->ino < r_map->ino) return 1;
991
992 if (l_map->ino_generation > r_map->ino_generation) return -1;
993 if (l_map->ino_generation < r_map->ino_generation) return 1;
994
995 /*
996 * Addresses with no major/minor numbers are assumed to be
997 * anonymous in userspace. Sort those on pid then address.
998 *
999 * The kernel and non-zero major/minor mapped areas are
1000 * assumed to be unity mapped. Sort those on address.
1001 */
1002
1003 if ((left->cpumode != PERF_RECORD_MISC_KERNEL) &&
1004 (!(l_map->flags & MAP_SHARED)) &&
1005 !l_map->maj && !l_map->min && !l_map->ino &&
1006 !l_map->ino_generation) {
1007 /* userspace anonymous */
1008
1009 if (left->thread->pid_ > right->thread->pid_) return -1;
1010 if (left->thread->pid_ < right->thread->pid_) return 1;
1011 }
1012
1013 addr:
1014 /* al_addr does all the right addr - start + offset calculations */
1015 l = cl_address(left->mem_info->daddr.al_addr);
1016 r = cl_address(right->mem_info->daddr.al_addr);
1017
1018 if (l > r) return -1;
1019 if (l < r) return 1;
1020
1021 return 0;
1022 }
1023
1024 static int hist_entry__dcacheline_snprintf(struct hist_entry *he, char *bf,
1025 size_t size, unsigned int width)
1026 {
1027
1028 uint64_t addr = 0;
1029 struct map *map = NULL;
1030 struct symbol *sym = NULL;
1031 char level = he->level;
1032
1033 if (he->mem_info) {
1034 addr = cl_address(he->mem_info->daddr.al_addr);
1035 map = he->mem_info->daddr.map;
1036 sym = he->mem_info->daddr.sym;
1037
1038 /* print [s] for shared data mmaps */
1039 if ((he->cpumode != PERF_RECORD_MISC_KERNEL) &&
1040 map && (map->type == MAP__VARIABLE) &&
1041 (map->flags & MAP_SHARED) &&
1042 (map->maj || map->min || map->ino ||
1043 map->ino_generation))
1044 level = 's';
1045 else if (!map)
1046 level = 'X';
1047 }
1048 return _hist_entry__sym_snprintf(map, sym, addr, level, bf, size,
1049 width);
1050 }
1051
1052 struct sort_entry sort_mispredict = {
1053 .se_header = "Branch Mispredicted",
1054 .se_cmp = sort__mispredict_cmp,
1055 .se_snprintf = hist_entry__mispredict_snprintf,
1056 .se_width_idx = HISTC_MISPREDICT,
1057 };
1058
1059 static u64 he_weight(struct hist_entry *he)
1060 {
1061 return he->stat.nr_events ? he->stat.weight / he->stat.nr_events : 0;
1062 }
1063
1064 static int64_t
1065 sort__local_weight_cmp(struct hist_entry *left, struct hist_entry *right)
1066 {
1067 return he_weight(left) - he_weight(right);
1068 }
1069
1070 static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf,
1071 size_t size, unsigned int width)
1072 {
1073 return repsep_snprintf(bf, size, "%-*llu", width, he_weight(he));
1074 }
1075
1076 struct sort_entry sort_local_weight = {
1077 .se_header = "Local Weight",
1078 .se_cmp = sort__local_weight_cmp,
1079 .se_snprintf = hist_entry__local_weight_snprintf,
1080 .se_width_idx = HISTC_LOCAL_WEIGHT,
1081 };
1082
1083 static int64_t
1084 sort__global_weight_cmp(struct hist_entry *left, struct hist_entry *right)
1085 {
1086 return left->stat.weight - right->stat.weight;
1087 }
1088
1089 static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf,
1090 size_t size, unsigned int width)
1091 {
1092 return repsep_snprintf(bf, size, "%-*llu", width, he->stat.weight);
1093 }
1094
1095 struct sort_entry sort_global_weight = {
1096 .se_header = "Weight",
1097 .se_cmp = sort__global_weight_cmp,
1098 .se_snprintf = hist_entry__global_weight_snprintf,
1099 .se_width_idx = HISTC_GLOBAL_WEIGHT,
1100 };
1101
1102 struct sort_entry sort_mem_daddr_sym = {
1103 .se_header = "Data Symbol",
1104 .se_cmp = sort__daddr_cmp,
1105 .se_snprintf = hist_entry__daddr_snprintf,
1106 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
1107 };
1108
1109 struct sort_entry sort_mem_iaddr_sym = {
1110 .se_header = "Code Symbol",
1111 .se_cmp = sort__iaddr_cmp,
1112 .se_snprintf = hist_entry__iaddr_snprintf,
1113 .se_width_idx = HISTC_MEM_IADDR_SYMBOL,
1114 };
1115
1116 struct sort_entry sort_mem_daddr_dso = {
1117 .se_header = "Data Object",
1118 .se_cmp = sort__dso_daddr_cmp,
1119 .se_snprintf = hist_entry__dso_daddr_snprintf,
1120 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
1121 };
1122
1123 struct sort_entry sort_mem_locked = {
1124 .se_header = "Locked",
1125 .se_cmp = sort__locked_cmp,
1126 .se_snprintf = hist_entry__locked_snprintf,
1127 .se_width_idx = HISTC_MEM_LOCKED,
1128 };
1129
1130 struct sort_entry sort_mem_tlb = {
1131 .se_header = "TLB access",
1132 .se_cmp = sort__tlb_cmp,
1133 .se_snprintf = hist_entry__tlb_snprintf,
1134 .se_width_idx = HISTC_MEM_TLB,
1135 };
1136
1137 struct sort_entry sort_mem_lvl = {
1138 .se_header = "Memory access",
1139 .se_cmp = sort__lvl_cmp,
1140 .se_snprintf = hist_entry__lvl_snprintf,
1141 .se_width_idx = HISTC_MEM_LVL,
1142 };
1143
1144 struct sort_entry sort_mem_snoop = {
1145 .se_header = "Snoop",
1146 .se_cmp = sort__snoop_cmp,
1147 .se_snprintf = hist_entry__snoop_snprintf,
1148 .se_width_idx = HISTC_MEM_SNOOP,
1149 };
1150
1151 struct sort_entry sort_mem_dcacheline = {
1152 .se_header = "Data Cacheline",
1153 .se_cmp = sort__dcacheline_cmp,
1154 .se_snprintf = hist_entry__dcacheline_snprintf,
1155 .se_width_idx = HISTC_MEM_DCACHELINE,
1156 };
1157
1158 static int64_t
1159 sort__abort_cmp(struct hist_entry *left, struct hist_entry *right)
1160 {
1161 if (!left->branch_info || !right->branch_info)
1162 return cmp_null(left->branch_info, right->branch_info);
1163
1164 return left->branch_info->flags.abort !=
1165 right->branch_info->flags.abort;
1166 }
1167
1168 static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf,
1169 size_t size, unsigned int width)
1170 {
1171 static const char *out = "N/A";
1172
1173 if (he->branch_info) {
1174 if (he->branch_info->flags.abort)
1175 out = "A";
1176 else
1177 out = ".";
1178 }
1179
1180 return repsep_snprintf(bf, size, "%-*s", width, out);
1181 }
1182
1183 struct sort_entry sort_abort = {
1184 .se_header = "Transaction abort",
1185 .se_cmp = sort__abort_cmp,
1186 .se_snprintf = hist_entry__abort_snprintf,
1187 .se_width_idx = HISTC_ABORT,
1188 };
1189
1190 static int64_t
1191 sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
1192 {
1193 if (!left->branch_info || !right->branch_info)
1194 return cmp_null(left->branch_info, right->branch_info);
1195
1196 return left->branch_info->flags.in_tx !=
1197 right->branch_info->flags.in_tx;
1198 }
1199
1200 static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf,
1201 size_t size, unsigned int width)
1202 {
1203 static const char *out = "N/A";
1204
1205 if (he->branch_info) {
1206 if (he->branch_info->flags.in_tx)
1207 out = "T";
1208 else
1209 out = ".";
1210 }
1211
1212 return repsep_snprintf(bf, size, "%-*s", width, out);
1213 }
1214
1215 struct sort_entry sort_in_tx = {
1216 .se_header = "Branch in transaction",
1217 .se_cmp = sort__in_tx_cmp,
1218 .se_snprintf = hist_entry__in_tx_snprintf,
1219 .se_width_idx = HISTC_IN_TX,
1220 };
1221
1222 static int64_t
1223 sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right)
1224 {
1225 return left->transaction - right->transaction;
1226 }
1227
1228 static inline char *add_str(char *p, const char *str)
1229 {
1230 strcpy(p, str);
1231 return p + strlen(str);
1232 }
1233
1234 static struct txbit {
1235 unsigned flag;
1236 const char *name;
1237 int skip_for_len;
1238 } txbits[] = {
1239 { PERF_TXN_ELISION, "EL ", 0 },
1240 { PERF_TXN_TRANSACTION, "TX ", 1 },
1241 { PERF_TXN_SYNC, "SYNC ", 1 },
1242 { PERF_TXN_ASYNC, "ASYNC ", 0 },
1243 { PERF_TXN_RETRY, "RETRY ", 0 },
1244 { PERF_TXN_CONFLICT, "CON ", 0 },
1245 { PERF_TXN_CAPACITY_WRITE, "CAP-WRITE ", 1 },
1246 { PERF_TXN_CAPACITY_READ, "CAP-READ ", 0 },
1247 { 0, NULL, 0 }
1248 };
1249
1250 int hist_entry__transaction_len(void)
1251 {
1252 int i;
1253 int len = 0;
1254
1255 for (i = 0; txbits[i].name; i++) {
1256 if (!txbits[i].skip_for_len)
1257 len += strlen(txbits[i].name);
1258 }
1259 len += 4; /* :XX<space> */
1260 return len;
1261 }
1262
1263 static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf,
1264 size_t size, unsigned int width)
1265 {
1266 u64 t = he->transaction;
1267 char buf[128];
1268 char *p = buf;
1269 int i;
1270
1271 buf[0] = 0;
1272 for (i = 0; txbits[i].name; i++)
1273 if (txbits[i].flag & t)
1274 p = add_str(p, txbits[i].name);
1275 if (t && !(t & (PERF_TXN_SYNC|PERF_TXN_ASYNC)))
1276 p = add_str(p, "NEITHER ");
1277 if (t & PERF_TXN_ABORT_MASK) {
1278 sprintf(p, ":%" PRIx64,
1279 (t & PERF_TXN_ABORT_MASK) >>
1280 PERF_TXN_ABORT_SHIFT);
1281 p += strlen(p);
1282 }
1283
1284 return repsep_snprintf(bf, size, "%-*s", width, buf);
1285 }
1286
1287 struct sort_entry sort_transaction = {
1288 .se_header = "Transaction ",
1289 .se_cmp = sort__transaction_cmp,
1290 .se_snprintf = hist_entry__transaction_snprintf,
1291 .se_width_idx = HISTC_TRANSACTION,
1292 };
1293
1294 struct sort_dimension {
1295 const char *name;
1296 struct sort_entry *entry;
1297 int taken;
1298 };
1299
1300 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
1301
1302 static struct sort_dimension common_sort_dimensions[] = {
1303 DIM(SORT_PID, "pid", sort_thread),
1304 DIM(SORT_COMM, "comm", sort_comm),
1305 DIM(SORT_DSO, "dso", sort_dso),
1306 DIM(SORT_SYM, "symbol", sort_sym),
1307 DIM(SORT_PARENT, "parent", sort_parent),
1308 DIM(SORT_CPU, "cpu", sort_cpu),
1309 DIM(SORT_SOCKET, "socket", sort_socket),
1310 DIM(SORT_SRCLINE, "srcline", sort_srcline),
1311 DIM(SORT_SRCFILE, "srcfile", sort_srcfile),
1312 DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
1313 DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
1314 DIM(SORT_TRANSACTION, "transaction", sort_transaction),
1315 };
1316
1317 #undef DIM
1318
1319 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
1320
1321 static struct sort_dimension bstack_sort_dimensions[] = {
1322 DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
1323 DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
1324 DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
1325 DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
1326 DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
1327 DIM(SORT_IN_TX, "in_tx", sort_in_tx),
1328 DIM(SORT_ABORT, "abort", sort_abort),
1329 DIM(SORT_CYCLES, "cycles", sort_cycles),
1330 };
1331
1332 #undef DIM
1333
1334 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
1335
1336 static struct sort_dimension memory_sort_dimensions[] = {
1337 DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
1338 DIM(SORT_MEM_IADDR_SYMBOL, "symbol_iaddr", sort_mem_iaddr_sym),
1339 DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
1340 DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
1341 DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
1342 DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
1343 DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
1344 DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline),
1345 };
1346
1347 #undef DIM
1348
1349 struct hpp_dimension {
1350 const char *name;
1351 struct perf_hpp_fmt *fmt;
1352 int taken;
1353 };
1354
1355 #define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], }
1356
1357 static struct hpp_dimension hpp_sort_dimensions[] = {
1358 DIM(PERF_HPP__OVERHEAD, "overhead"),
1359 DIM(PERF_HPP__OVERHEAD_SYS, "overhead_sys"),
1360 DIM(PERF_HPP__OVERHEAD_US, "overhead_us"),
1361 DIM(PERF_HPP__OVERHEAD_GUEST_SYS, "overhead_guest_sys"),
1362 DIM(PERF_HPP__OVERHEAD_GUEST_US, "overhead_guest_us"),
1363 DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"),
1364 DIM(PERF_HPP__SAMPLES, "sample"),
1365 DIM(PERF_HPP__PERIOD, "period"),
1366 };
1367
1368 #undef DIM
1369
1370 struct hpp_sort_entry {
1371 struct perf_hpp_fmt hpp;
1372 struct sort_entry *se;
1373 };
1374
1375 bool perf_hpp__same_sort_entry(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
1376 {
1377 struct hpp_sort_entry *hse_a;
1378 struct hpp_sort_entry *hse_b;
1379
1380 if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b))
1381 return false;
1382
1383 hse_a = container_of(a, struct hpp_sort_entry, hpp);
1384 hse_b = container_of(b, struct hpp_sort_entry, hpp);
1385
1386 return hse_a->se == hse_b->se;
1387 }
1388
1389 void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
1390 {
1391 struct hpp_sort_entry *hse;
1392
1393 if (!perf_hpp__is_sort_entry(fmt))
1394 return;
1395
1396 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1397 hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
1398 }
1399
1400 static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1401 struct perf_evsel *evsel)
1402 {
1403 struct hpp_sort_entry *hse;
1404 size_t len = fmt->user_len;
1405
1406 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1407
1408 if (!len)
1409 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1410
1411 return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
1412 }
1413
1414 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
1415 struct perf_hpp *hpp __maybe_unused,
1416 struct perf_evsel *evsel)
1417 {
1418 struct hpp_sort_entry *hse;
1419 size_t len = fmt->user_len;
1420
1421 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1422
1423 if (!len)
1424 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1425
1426 return len;
1427 }
1428
1429 static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1430 struct hist_entry *he)
1431 {
1432 struct hpp_sort_entry *hse;
1433 size_t len = fmt->user_len;
1434
1435 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1436
1437 if (!len)
1438 len = hists__col_len(he->hists, hse->se->se_width_idx);
1439
1440 return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
1441 }
1442
1443 static int64_t __sort__hpp_cmp(struct perf_hpp_fmt *fmt,
1444 struct hist_entry *a, struct hist_entry *b)
1445 {
1446 struct hpp_sort_entry *hse;
1447
1448 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1449 return hse->se->se_cmp(a, b);
1450 }
1451
1452 static int64_t __sort__hpp_collapse(struct perf_hpp_fmt *fmt,
1453 struct hist_entry *a, struct hist_entry *b)
1454 {
1455 struct hpp_sort_entry *hse;
1456 int64_t (*collapse_fn)(struct hist_entry *, struct hist_entry *);
1457
1458 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1459 collapse_fn = hse->se->se_collapse ?: hse->se->se_cmp;
1460 return collapse_fn(a, b);
1461 }
1462
1463 static int64_t __sort__hpp_sort(struct perf_hpp_fmt *fmt,
1464 struct hist_entry *a, struct hist_entry *b)
1465 {
1466 struct hpp_sort_entry *hse;
1467 int64_t (*sort_fn)(struct hist_entry *, struct hist_entry *);
1468
1469 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1470 sort_fn = hse->se->se_sort ?: hse->se->se_cmp;
1471 return sort_fn(a, b);
1472 }
1473
1474 static struct hpp_sort_entry *
1475 __sort_dimension__alloc_hpp(struct sort_dimension *sd)
1476 {
1477 struct hpp_sort_entry *hse;
1478
1479 hse = malloc(sizeof(*hse));
1480 if (hse == NULL) {
1481 pr_err("Memory allocation failed\n");
1482 return NULL;
1483 }
1484
1485 hse->se = sd->entry;
1486 hse->hpp.name = sd->entry->se_header;
1487 hse->hpp.header = __sort__hpp_header;
1488 hse->hpp.width = __sort__hpp_width;
1489 hse->hpp.entry = __sort__hpp_entry;
1490 hse->hpp.color = NULL;
1491
1492 hse->hpp.cmp = __sort__hpp_cmp;
1493 hse->hpp.collapse = __sort__hpp_collapse;
1494 hse->hpp.sort = __sort__hpp_sort;
1495
1496 INIT_LIST_HEAD(&hse->hpp.list);
1497 INIT_LIST_HEAD(&hse->hpp.sort_list);
1498 hse->hpp.elide = false;
1499 hse->hpp.len = 0;
1500 hse->hpp.user_len = 0;
1501
1502 return hse;
1503 }
1504
1505 bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)
1506 {
1507 return format->header == __sort__hpp_header;
1508 }
1509
1510 static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd)
1511 {
1512 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1513
1514 if (hse == NULL)
1515 return -1;
1516
1517 perf_hpp__register_sort_field(&hse->hpp);
1518 return 0;
1519 }
1520
1521 static int __sort_dimension__add_hpp_output(struct sort_dimension *sd)
1522 {
1523 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1524
1525 if (hse == NULL)
1526 return -1;
1527
1528 perf_hpp__column_register(&hse->hpp);
1529 return 0;
1530 }
1531
1532 static int __sort_dimension__add(struct sort_dimension *sd)
1533 {
1534 if (sd->taken)
1535 return 0;
1536
1537 if (__sort_dimension__add_hpp_sort(sd) < 0)
1538 return -1;
1539
1540 if (sd->entry->se_collapse)
1541 sort__need_collapse = 1;
1542
1543 sd->taken = 1;
1544
1545 return 0;
1546 }
1547
1548 static int __hpp_dimension__add(struct hpp_dimension *hd)
1549 {
1550 if (!hd->taken) {
1551 hd->taken = 1;
1552
1553 perf_hpp__register_sort_field(hd->fmt);
1554 }
1555 return 0;
1556 }
1557
1558 static int __sort_dimension__add_output(struct sort_dimension *sd)
1559 {
1560 if (sd->taken)
1561 return 0;
1562
1563 if (__sort_dimension__add_hpp_output(sd) < 0)
1564 return -1;
1565
1566 sd->taken = 1;
1567 return 0;
1568 }
1569
1570 static int __hpp_dimension__add_output(struct hpp_dimension *hd)
1571 {
1572 if (!hd->taken) {
1573 hd->taken = 1;
1574
1575 perf_hpp__column_register(hd->fmt);
1576 }
1577 return 0;
1578 }
1579
1580 int hpp_dimension__add_output(unsigned col)
1581 {
1582 BUG_ON(col >= PERF_HPP__MAX_INDEX);
1583 return __hpp_dimension__add_output(&hpp_sort_dimensions[col]);
1584 }
1585
1586 int sort_dimension__add(const char *tok)
1587 {
1588 unsigned int i;
1589
1590 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
1591 struct sort_dimension *sd = &common_sort_dimensions[i];
1592
1593 if (strncasecmp(tok, sd->name, strlen(tok)))
1594 continue;
1595
1596 if (sd->entry == &sort_parent) {
1597 int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
1598 if (ret) {
1599 char err[BUFSIZ];
1600
1601 regerror(ret, &parent_regex, err, sizeof(err));
1602 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
1603 return -EINVAL;
1604 }
1605 sort__has_parent = 1;
1606 } else if (sd->entry == &sort_sym) {
1607 sort__has_sym = 1;
1608 /*
1609 * perf diff displays the performance difference amongst
1610 * two or more perf.data files. Those files could come
1611 * from different binaries. So we should not compare
1612 * their ips, but the name of symbol.
1613 */
1614 if (sort__mode == SORT_MODE__DIFF)
1615 sd->entry->se_collapse = sort__sym_sort;
1616
1617 } else if (sd->entry == &sort_dso) {
1618 sort__has_dso = 1;
1619 } else if (sd->entry == &sort_socket) {
1620 sort__has_socket = 1;
1621 }
1622
1623 return __sort_dimension__add(sd);
1624 }
1625
1626 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
1627 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
1628
1629 if (strncasecmp(tok, hd->name, strlen(tok)))
1630 continue;
1631
1632 return __hpp_dimension__add(hd);
1633 }
1634
1635 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
1636 struct sort_dimension *sd = &bstack_sort_dimensions[i];
1637
1638 if (strncasecmp(tok, sd->name, strlen(tok)))
1639 continue;
1640
1641 if (sort__mode != SORT_MODE__BRANCH)
1642 return -EINVAL;
1643
1644 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
1645 sort__has_sym = 1;
1646
1647 __sort_dimension__add(sd);
1648 return 0;
1649 }
1650
1651 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
1652 struct sort_dimension *sd = &memory_sort_dimensions[i];
1653
1654 if (strncasecmp(tok, sd->name, strlen(tok)))
1655 continue;
1656
1657 if (sort__mode != SORT_MODE__MEMORY)
1658 return -EINVAL;
1659
1660 if (sd->entry == &sort_mem_daddr_sym)
1661 sort__has_sym = 1;
1662
1663 __sort_dimension__add(sd);
1664 return 0;
1665 }
1666
1667 return -ESRCH;
1668 }
1669
1670 static const char *get_default_sort_order(void)
1671 {
1672 const char *default_sort_orders[] = {
1673 default_sort_order,
1674 default_branch_sort_order,
1675 default_mem_sort_order,
1676 default_top_sort_order,
1677 default_diff_sort_order,
1678 };
1679
1680 BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders));
1681
1682 return default_sort_orders[sort__mode];
1683 }
1684
1685 static int setup_sort_order(void)
1686 {
1687 char *new_sort_order;
1688
1689 /*
1690 * Append '+'-prefixed sort order to the default sort
1691 * order string.
1692 */
1693 if (!sort_order || is_strict_order(sort_order))
1694 return 0;
1695
1696 if (sort_order[1] == '\0') {
1697 error("Invalid --sort key: `+'");
1698 return -EINVAL;
1699 }
1700
1701 /*
1702 * We allocate new sort_order string, but we never free it,
1703 * because it's checked over the rest of the code.
1704 */
1705 if (asprintf(&new_sort_order, "%s,%s",
1706 get_default_sort_order(), sort_order + 1) < 0) {
1707 error("Not enough memory to set up --sort");
1708 return -ENOMEM;
1709 }
1710
1711 sort_order = new_sort_order;
1712 return 0;
1713 }
1714
1715 static int __setup_sorting(void)
1716 {
1717 char *tmp, *tok, *str;
1718 const char *sort_keys;
1719 int ret = 0;
1720
1721 ret = setup_sort_order();
1722 if (ret)
1723 return ret;
1724
1725 sort_keys = sort_order;
1726 if (sort_keys == NULL) {
1727 if (is_strict_order(field_order)) {
1728 /*
1729 * If user specified field order but no sort order,
1730 * we'll honor it and not add default sort orders.
1731 */
1732 return 0;
1733 }
1734
1735 sort_keys = get_default_sort_order();
1736 }
1737
1738 str = strdup(sort_keys);
1739 if (str == NULL) {
1740 error("Not enough memory to setup sort keys");
1741 return -ENOMEM;
1742 }
1743
1744 for (tok = strtok_r(str, ", ", &tmp);
1745 tok; tok = strtok_r(NULL, ", ", &tmp)) {
1746 ret = sort_dimension__add(tok);
1747 if (ret == -EINVAL) {
1748 error("Invalid --sort key: `%s'", tok);
1749 break;
1750 } else if (ret == -ESRCH) {
1751 error("Unknown --sort key: `%s'", tok);
1752 break;
1753 }
1754 }
1755
1756 free(str);
1757 return ret;
1758 }
1759
1760 void perf_hpp__set_elide(int idx, bool elide)
1761 {
1762 struct perf_hpp_fmt *fmt;
1763 struct hpp_sort_entry *hse;
1764
1765 perf_hpp__for_each_format(fmt) {
1766 if (!perf_hpp__is_sort_entry(fmt))
1767 continue;
1768
1769 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1770 if (hse->se->se_width_idx == idx) {
1771 fmt->elide = elide;
1772 break;
1773 }
1774 }
1775 }
1776
1777 static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp)
1778 {
1779 if (list && strlist__nr_entries(list) == 1) {
1780 if (fp != NULL)
1781 fprintf(fp, "# %s: %s\n", list_name,
1782 strlist__entry(list, 0)->s);
1783 return true;
1784 }
1785 return false;
1786 }
1787
1788 static bool get_elide(int idx, FILE *output)
1789 {
1790 switch (idx) {
1791 case HISTC_SYMBOL:
1792 return __get_elide(symbol_conf.sym_list, "symbol", output);
1793 case HISTC_DSO:
1794 return __get_elide(symbol_conf.dso_list, "dso", output);
1795 case HISTC_COMM:
1796 return __get_elide(symbol_conf.comm_list, "comm", output);
1797 default:
1798 break;
1799 }
1800
1801 if (sort__mode != SORT_MODE__BRANCH)
1802 return false;
1803
1804 switch (idx) {
1805 case HISTC_SYMBOL_FROM:
1806 return __get_elide(symbol_conf.sym_from_list, "sym_from", output);
1807 case HISTC_SYMBOL_TO:
1808 return __get_elide(symbol_conf.sym_to_list, "sym_to", output);
1809 case HISTC_DSO_FROM:
1810 return __get_elide(symbol_conf.dso_from_list, "dso_from", output);
1811 case HISTC_DSO_TO:
1812 return __get_elide(symbol_conf.dso_to_list, "dso_to", output);
1813 default:
1814 break;
1815 }
1816
1817 return false;
1818 }
1819
1820 void sort__setup_elide(FILE *output)
1821 {
1822 struct perf_hpp_fmt *fmt;
1823 struct hpp_sort_entry *hse;
1824
1825 perf_hpp__for_each_format(fmt) {
1826 if (!perf_hpp__is_sort_entry(fmt))
1827 continue;
1828
1829 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1830 fmt->elide = get_elide(hse->se->se_width_idx, output);
1831 }
1832
1833 /*
1834 * It makes no sense to elide all of sort entries.
1835 * Just revert them to show up again.
1836 */
1837 perf_hpp__for_each_format(fmt) {
1838 if (!perf_hpp__is_sort_entry(fmt))
1839 continue;
1840
1841 if (!fmt->elide)
1842 return;
1843 }
1844
1845 perf_hpp__for_each_format(fmt) {
1846 if (!perf_hpp__is_sort_entry(fmt))
1847 continue;
1848
1849 fmt->elide = false;
1850 }
1851 }
1852
1853 static int output_field_add(char *tok)
1854 {
1855 unsigned int i;
1856
1857 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
1858 struct sort_dimension *sd = &common_sort_dimensions[i];
1859
1860 if (strncasecmp(tok, sd->name, strlen(tok)))
1861 continue;
1862
1863 return __sort_dimension__add_output(sd);
1864 }
1865
1866 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
1867 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
1868
1869 if (strncasecmp(tok, hd->name, strlen(tok)))
1870 continue;
1871
1872 return __hpp_dimension__add_output(hd);
1873 }
1874
1875 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
1876 struct sort_dimension *sd = &bstack_sort_dimensions[i];
1877
1878 if (strncasecmp(tok, sd->name, strlen(tok)))
1879 continue;
1880
1881 return __sort_dimension__add_output(sd);
1882 }
1883
1884 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
1885 struct sort_dimension *sd = &memory_sort_dimensions[i];
1886
1887 if (strncasecmp(tok, sd->name, strlen(tok)))
1888 continue;
1889
1890 return __sort_dimension__add_output(sd);
1891 }
1892
1893 return -ESRCH;
1894 }
1895
1896 static void reset_dimensions(void)
1897 {
1898 unsigned int i;
1899
1900 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++)
1901 common_sort_dimensions[i].taken = 0;
1902
1903 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++)
1904 hpp_sort_dimensions[i].taken = 0;
1905
1906 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++)
1907 bstack_sort_dimensions[i].taken = 0;
1908
1909 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++)
1910 memory_sort_dimensions[i].taken = 0;
1911 }
1912
1913 bool is_strict_order(const char *order)
1914 {
1915 return order && (*order != '+');
1916 }
1917
1918 static int __setup_output_field(void)
1919 {
1920 char *tmp, *tok, *str, *strp;
1921 int ret = -EINVAL;
1922
1923 if (field_order == NULL)
1924 return 0;
1925
1926 strp = str = strdup(field_order);
1927 if (str == NULL) {
1928 error("Not enough memory to setup output fields");
1929 return -ENOMEM;
1930 }
1931
1932 if (!is_strict_order(field_order))
1933 strp++;
1934
1935 if (!strlen(strp)) {
1936 error("Invalid --fields key: `+'");
1937 goto out;
1938 }
1939
1940 for (tok = strtok_r(strp, ", ", &tmp);
1941 tok; tok = strtok_r(NULL, ", ", &tmp)) {
1942 ret = output_field_add(tok);
1943 if (ret == -EINVAL) {
1944 error("Invalid --fields key: `%s'", tok);
1945 break;
1946 } else if (ret == -ESRCH) {
1947 error("Unknown --fields key: `%s'", tok);
1948 break;
1949 }
1950 }
1951
1952 out:
1953 free(str);
1954 return ret;
1955 }
1956
1957 int setup_sorting(void)
1958 {
1959 int err;
1960
1961 err = __setup_sorting();
1962 if (err < 0)
1963 return err;
1964
1965 if (parent_pattern != default_parent_pattern) {
1966 err = sort_dimension__add("parent");
1967 if (err < 0)
1968 return err;
1969 }
1970
1971 reset_dimensions();
1972
1973 /*
1974 * perf diff doesn't use default hpp output fields.
1975 */
1976 if (sort__mode != SORT_MODE__DIFF)
1977 perf_hpp__init();
1978
1979 err = __setup_output_field();
1980 if (err < 0)
1981 return err;
1982
1983 /* copy sort keys to output fields */
1984 perf_hpp__setup_output_field();
1985 /* and then copy output fields to sort keys */
1986 perf_hpp__append_sort_keys();
1987
1988 return 0;
1989 }
1990
1991 void reset_output_field(void)
1992 {
1993 sort__need_collapse = 0;
1994 sort__has_parent = 0;
1995 sort__has_sym = 0;
1996 sort__has_dso = 0;
1997
1998 field_order = NULL;
1999 sort_order = NULL;
2000
2001 reset_dimensions();
2002 perf_hpp__reset_output_field();
2003 }
Linux with added FPC-III support