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