?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/xen: resume timer irqs early
[linux/fpc-iii.git] / tools / perf / util / sort.c
blob5f118a089519a46bb6b370536660476bc6880eda
1 #include "sort.h"
2 #include "hist.h"
3 #include "symbol.h"
4
5 regex_t parent_regex;
6 const char default_parent_pattern[] = "^sys_|^do_page_fault";
7 const char *parent_pattern = default_parent_pattern;
8 const char default_sort_order[] = "comm,dso,symbol";
9 const char *sort_order = default_sort_order;
10 regex_t ignore_callees_regex;
11 int have_ignore_callees = 0;
12 int sort__need_collapse = 0;
13 int sort__has_parent = 0;
14 int sort__has_sym = 0;
15 enum sort_mode sort__mode = SORT_MODE__NORMAL;
16
17 enum sort_type sort__first_dimension;
18
19 LIST_HEAD(hist_entry__sort_list);
20
21 static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
22 {
23 int n;
24 va_list ap;
25
26 va_start(ap, fmt);
27 n = vsnprintf(bf, size, fmt, ap);
28 if (symbol_conf.field_sep && n > 0) {
29 char *sep = bf;
30
31 while (1) {
32 sep = strchr(sep, *symbol_conf.field_sep);
33 if (sep == NULL)
34 break;
35 *sep = '.';
36 }
37 }
38 va_end(ap);
39
40 if (n >= (int)size)
41 return size - 1;
42 return n;
43 }
44
45 static int64_t cmp_null(void *l, void *r)
46 {
47 if (!l && !r)
48 return 0;
49 else if (!l)
50 return -1;
51 else
52 return 1;
53 }
54
55 /* --sort pid */
56
57 static int64_t
58 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
59 {
60 return right->thread->tid - left->thread->tid;
61 }
62
63 static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
64 size_t size, unsigned int width)
65 {
66 return repsep_snprintf(bf, size, "%*s:%5d", width - 6,
67 self->thread->comm ?: "", self->thread->tid);
68 }
69
70 struct sort_entry sort_thread = {
71 .se_header = "Command: Pid",
72 .se_cmp = sort__thread_cmp,
73 .se_snprintf = hist_entry__thread_snprintf,
74 .se_width_idx = HISTC_THREAD,
75 };
76
77 /* --sort comm */
78
79 static int64_t
80 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
81 {
82 return right->thread->tid - left->thread->tid;
83 }
84
85 static int64_t
86 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
87 {
88 char *comm_l = left->thread->comm;
89 char *comm_r = right->thread->comm;
90
91 if (!comm_l || !comm_r)
92 return cmp_null(comm_l, comm_r);
93
94 return strcmp(comm_l, comm_r);
95 }
96
97 static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
98 size_t size, unsigned int width)
99 {
100 return repsep_snprintf(bf, size, "%*s", width, self->thread->comm);
101 }
102
103 struct sort_entry sort_comm = {
104 .se_header = "Command",
105 .se_cmp = sort__comm_cmp,
106 .se_collapse = sort__comm_collapse,
107 .se_snprintf = hist_entry__comm_snprintf,
108 .se_width_idx = HISTC_COMM,
109 };
110
111 /* --sort dso */
112
113 static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
114 {
115 struct dso *dso_l = map_l ? map_l->dso : NULL;
116 struct dso *dso_r = map_r ? map_r->dso : NULL;
117 const char *dso_name_l, *dso_name_r;
118
119 if (!dso_l || !dso_r)
120 return cmp_null(dso_l, dso_r);
121
122 if (verbose) {
123 dso_name_l = dso_l->long_name;
124 dso_name_r = dso_r->long_name;
125 } else {
126 dso_name_l = dso_l->short_name;
127 dso_name_r = dso_r->short_name;
128 }
129
130 return strcmp(dso_name_l, dso_name_r);
131 }
132
133 static int64_t
134 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
135 {
136 return _sort__dso_cmp(left->ms.map, right->ms.map);
137 }
138
139 static int _hist_entry__dso_snprintf(struct map *map, char *bf,
140 size_t size, unsigned int width)
141 {
142 if (map && map->dso) {
143 const char *dso_name = !verbose ? map->dso->short_name :
144 map->dso->long_name;
145 return repsep_snprintf(bf, size, "%-*s", width, dso_name);
146 }
147
148 return repsep_snprintf(bf, size, "%-*s", width, "[unknown]");
149 }
150
151 static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
152 size_t size, unsigned int width)
153 {
154 return _hist_entry__dso_snprintf(self->ms.map, bf, size, width);
155 }
156
157 struct sort_entry sort_dso = {
158 .se_header = "Shared Object",
159 .se_cmp = sort__dso_cmp,
160 .se_snprintf = hist_entry__dso_snprintf,
161 .se_width_idx = HISTC_DSO,
162 };
163
164 /* --sort symbol */
165
166 static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
167 {
168 u64 ip_l, ip_r;
169
170 if (!sym_l || !sym_r)
171 return cmp_null(sym_l, sym_r);
172
173 if (sym_l == sym_r)
174 return 0;
175
176 ip_l = sym_l->start;
177 ip_r = sym_r->start;
178
179 return (int64_t)(ip_r - ip_l);
180 }
181
182 static int64_t
183 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
184 {
185 if (!left->ms.sym && !right->ms.sym)
186 return right->level - left->level;
187
188 return _sort__sym_cmp(left->ms.sym, right->ms.sym);
189 }
190
191 static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
192 u64 ip, char level, char *bf, size_t size,
193 unsigned int width)
194 {
195 size_t ret = 0;
196
197 if (verbose) {
198 char o = map ? dso__symtab_origin(map->dso) : '!';
199 ret += repsep_snprintf(bf, size, "%-#*llx %c ",
200 BITS_PER_LONG / 4 + 2, ip, o);
201 }
202
203 ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
204 if (sym && map) {
205 if (map->type == MAP__VARIABLE) {
206 ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
207 ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
208 ip - map->unmap_ip(map, sym->start));
209 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
210 width - ret, "");
211 } else {
212 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
213 width - ret,
214 sym->name);
215 }
216 } else {
217 size_t len = BITS_PER_LONG / 4;
218 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
219 len, ip);
220 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
221 width - ret, "");
222 }
223
224 return ret;
225 }
226
227 static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
228 size_t size, unsigned int width)
229 {
230 return _hist_entry__sym_snprintf(self->ms.map, self->ms.sym, self->ip,
231 self->level, bf, size, width);
232 }
233
234 struct sort_entry sort_sym = {
235 .se_header = "Symbol",
236 .se_cmp = sort__sym_cmp,
237 .se_snprintf = hist_entry__sym_snprintf,
238 .se_width_idx = HISTC_SYMBOL,
239 };
240
241 /* --sort srcline */
242
243 static int64_t
244 sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
245 {
246 return (int64_t)(right->ip - left->ip);
247 }
248
249 static int hist_entry__srcline_snprintf(struct hist_entry *self, char *bf,
250 size_t size,
251 unsigned int width __maybe_unused)
252 {
253 FILE *fp = NULL;
254 char cmd[PATH_MAX + 2], *path = self->srcline, *nl;
255 size_t line_len;
256
257 if (path != NULL)
258 goto out_path;
259
260 if (!self->ms.map)
261 goto out_ip;
262
263 if (!strncmp(self->ms.map->dso->long_name, "/tmp/perf-", 10))
264 goto out_ip;
265
266 snprintf(cmd, sizeof(cmd), "addr2line -e %s %016" PRIx64,
267 self->ms.map->dso->long_name, self->ip);
268 fp = popen(cmd, "r");
269 if (!fp)
270 goto out_ip;
271
272 if (getline(&path, &line_len, fp) < 0 || !line_len)
273 goto out_ip;
274 self->srcline = strdup(path);
275 if (self->srcline == NULL)
276 goto out_ip;
277
278 nl = strchr(self->srcline, '\n');
279 if (nl != NULL)
280 *nl = '\0';
281 path = self->srcline;
282 out_path:
283 if (fp)
284 pclose(fp);
285 return repsep_snprintf(bf, size, "%s", path);
286 out_ip:
287 if (fp)
288 pclose(fp);
289 return repsep_snprintf(bf, size, "%-#*llx", BITS_PER_LONG / 4, self->ip);
290 }
291
292 struct sort_entry sort_srcline = {
293 .se_header = "Source:Line",
294 .se_cmp = sort__srcline_cmp,
295 .se_snprintf = hist_entry__srcline_snprintf,
296 .se_width_idx = HISTC_SRCLINE,
297 };
298
299 /* --sort parent */
300
301 static int64_t
302 sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
303 {
304 struct symbol *sym_l = left->parent;
305 struct symbol *sym_r = right->parent;
306
307 if (!sym_l || !sym_r)
308 return cmp_null(sym_l, sym_r);
309
310 return strcmp(sym_l->name, sym_r->name);
311 }
312
313 static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
314 size_t size, unsigned int width)
315 {
316 return repsep_snprintf(bf, size, "%-*s", width,
317 self->parent ? self->parent->name : "[other]");
318 }
319
320 struct sort_entry sort_parent = {
321 .se_header = "Parent symbol",
322 .se_cmp = sort__parent_cmp,
323 .se_snprintf = hist_entry__parent_snprintf,
324 .se_width_idx = HISTC_PARENT,
325 };
326
327 /* --sort cpu */
328
329 static int64_t
330 sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
331 {
332 return right->cpu - left->cpu;
333 }
334
335 static int hist_entry__cpu_snprintf(struct hist_entry *self, char *bf,
336 size_t size, unsigned int width)
337 {
338 return repsep_snprintf(bf, size, "%*d", width, self->cpu);
339 }
340
341 struct sort_entry sort_cpu = {
342 .se_header = "CPU",
343 .se_cmp = sort__cpu_cmp,
344 .se_snprintf = hist_entry__cpu_snprintf,
345 .se_width_idx = HISTC_CPU,
346 };
347
348 /* sort keys for branch stacks */
349
350 static int64_t
351 sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
352 {
353 return _sort__dso_cmp(left->branch_info->from.map,
354 right->branch_info->from.map);
355 }
356
357 static int hist_entry__dso_from_snprintf(struct hist_entry *self, char *bf,
358 size_t size, unsigned int width)
359 {
360 return _hist_entry__dso_snprintf(self->branch_info->from.map,
361 bf, size, width);
362 }
363
364 static int64_t
365 sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
366 {
367 return _sort__dso_cmp(left->branch_info->to.map,
368 right->branch_info->to.map);
369 }
370
371 static int hist_entry__dso_to_snprintf(struct hist_entry *self, char *bf,
372 size_t size, unsigned int width)
373 {
374 return _hist_entry__dso_snprintf(self->branch_info->to.map,
375 bf, size, width);
376 }
377
378 static int64_t
379 sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
380 {
381 struct addr_map_symbol *from_l = &left->branch_info->from;
382 struct addr_map_symbol *from_r = &right->branch_info->from;
383
384 if (!from_l->sym && !from_r->sym)
385 return right->level - left->level;
386
387 return _sort__sym_cmp(from_l->sym, from_r->sym);
388 }
389
390 static int64_t
391 sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
392 {
393 struct addr_map_symbol *to_l = &left->branch_info->to;
394 struct addr_map_symbol *to_r = &right->branch_info->to;
395
396 if (!to_l->sym && !to_r->sym)
397 return right->level - left->level;
398
399 return _sort__sym_cmp(to_l->sym, to_r->sym);
400 }
401
402 static int hist_entry__sym_from_snprintf(struct hist_entry *self, char *bf,
403 size_t size, unsigned int width)
404 {
405 struct addr_map_symbol *from = &self->branch_info->from;
406 return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
407 self->level, bf, size, width);
408
409 }
410
411 static int hist_entry__sym_to_snprintf(struct hist_entry *self, char *bf,
412 size_t size, unsigned int width)
413 {
414 struct addr_map_symbol *to = &self->branch_info->to;
415 return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
416 self->level, bf, size, width);
417
418 }
419
420 struct sort_entry sort_dso_from = {
421 .se_header = "Source Shared Object",
422 .se_cmp = sort__dso_from_cmp,
423 .se_snprintf = hist_entry__dso_from_snprintf,
424 .se_width_idx = HISTC_DSO_FROM,
425 };
426
427 struct sort_entry sort_dso_to = {
428 .se_header = "Target Shared Object",
429 .se_cmp = sort__dso_to_cmp,
430 .se_snprintf = hist_entry__dso_to_snprintf,
431 .se_width_idx = HISTC_DSO_TO,
432 };
433
434 struct sort_entry sort_sym_from = {
435 .se_header = "Source Symbol",
436 .se_cmp = sort__sym_from_cmp,
437 .se_snprintf = hist_entry__sym_from_snprintf,
438 .se_width_idx = HISTC_SYMBOL_FROM,
439 };
440
441 struct sort_entry sort_sym_to = {
442 .se_header = "Target Symbol",
443 .se_cmp = sort__sym_to_cmp,
444 .se_snprintf = hist_entry__sym_to_snprintf,
445 .se_width_idx = HISTC_SYMBOL_TO,
446 };
447
448 static int64_t
449 sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
450 {
451 const unsigned char mp = left->branch_info->flags.mispred !=
452 right->branch_info->flags.mispred;
453 const unsigned char p = left->branch_info->flags.predicted !=
454 right->branch_info->flags.predicted;
455
456 return mp || p;
457 }
458
459 static int hist_entry__mispredict_snprintf(struct hist_entry *self, char *bf,
460 size_t size, unsigned int width){
461 static const char *out = "N/A";
462
463 if (self->branch_info->flags.predicted)
464 out = "N";
465 else if (self->branch_info->flags.mispred)
466 out = "Y";
467
468 return repsep_snprintf(bf, size, "%-*s", width, out);
469 }
470
471 /* --sort daddr_sym */
472 static int64_t
473 sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
474 {
475 uint64_t l = 0, r = 0;
476
477 if (left->mem_info)
478 l = left->mem_info->daddr.addr;
479 if (right->mem_info)
480 r = right->mem_info->daddr.addr;
481
482 return (int64_t)(r - l);
483 }
484
485 static int hist_entry__daddr_snprintf(struct hist_entry *self, char *bf,
486 size_t size, unsigned int width)
487 {
488 uint64_t addr = 0;
489 struct map *map = NULL;
490 struct symbol *sym = NULL;
491
492 if (self->mem_info) {
493 addr = self->mem_info->daddr.addr;
494 map = self->mem_info->daddr.map;
495 sym = self->mem_info->daddr.sym;
496 }
497 return _hist_entry__sym_snprintf(map, sym, addr, self->level, bf, size,
498 width);
499 }
500
501 static int64_t
502 sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
503 {
504 struct map *map_l = NULL;
505 struct map *map_r = NULL;
506
507 if (left->mem_info)
508 map_l = left->mem_info->daddr.map;
509 if (right->mem_info)
510 map_r = right->mem_info->daddr.map;
511
512 return _sort__dso_cmp(map_l, map_r);
513 }
514
515 static int hist_entry__dso_daddr_snprintf(struct hist_entry *self, char *bf,
516 size_t size, unsigned int width)
517 {
518 struct map *map = NULL;
519
520 if (self->mem_info)
521 map = self->mem_info->daddr.map;
522
523 return _hist_entry__dso_snprintf(map, bf, size, width);
524 }
525
526 static int64_t
527 sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
528 {
529 union perf_mem_data_src data_src_l;
530 union perf_mem_data_src data_src_r;
531
532 if (left->mem_info)
533 data_src_l = left->mem_info->data_src;
534 else
535 data_src_l.mem_lock = PERF_MEM_LOCK_NA;
536
537 if (right->mem_info)
538 data_src_r = right->mem_info->data_src;
539 else
540 data_src_r.mem_lock = PERF_MEM_LOCK_NA;
541
542 return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
543 }
544
545 static int hist_entry__locked_snprintf(struct hist_entry *self, char *bf,
546 size_t size, unsigned int width)
547 {
548 const char *out;
549 u64 mask = PERF_MEM_LOCK_NA;
550
551 if (self->mem_info)
552 mask = self->mem_info->data_src.mem_lock;
553
554 if (mask & PERF_MEM_LOCK_NA)
555 out = "N/A";
556 else if (mask & PERF_MEM_LOCK_LOCKED)
557 out = "Yes";
558 else
559 out = "No";
560
561 return repsep_snprintf(bf, size, "%-*s", width, out);
562 }
563
564 static int64_t
565 sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
566 {
567 union perf_mem_data_src data_src_l;
568 union perf_mem_data_src data_src_r;
569
570 if (left->mem_info)
571 data_src_l = left->mem_info->data_src;
572 else
573 data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
574
575 if (right->mem_info)
576 data_src_r = right->mem_info->data_src;
577 else
578 data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
579
580 return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
581 }
582
583 static const char * const tlb_access[] = {
584 "N/A",
585 "HIT",
586 "MISS",
587 "L1",
588 "L2",
589 "Walker",
590 "Fault",
591 };
592 #define NUM_TLB_ACCESS (sizeof(tlb_access)/sizeof(const char *))
593
594 static int hist_entry__tlb_snprintf(struct hist_entry *self, char *bf,
595 size_t size, unsigned int width)
596 {
597 char out[64];
598 size_t sz = sizeof(out) - 1; /* -1 for null termination */
599 size_t l = 0, i;
600 u64 m = PERF_MEM_TLB_NA;
601 u64 hit, miss;
602
603 out[0] = '\0';
604
605 if (self->mem_info)
606 m = self->mem_info->data_src.mem_dtlb;
607
608 hit = m & PERF_MEM_TLB_HIT;
609 miss = m & PERF_MEM_TLB_MISS;
610
611 /* already taken care of */
612 m &= ~(PERF_MEM_TLB_HIT|PERF_MEM_TLB_MISS);
613
614 for (i = 0; m && i < NUM_TLB_ACCESS; i++, m >>= 1) {
615 if (!(m & 0x1))
616 continue;
617 if (l) {
618 strcat(out, " or ");
619 l += 4;
620 }
621 strncat(out, tlb_access[i], sz - l);
622 l += strlen(tlb_access[i]);
623 }
624 if (*out == '\0')
625 strcpy(out, "N/A");
626 if (hit)
627 strncat(out, " hit", sz - l);
628 if (miss)
629 strncat(out, " miss", sz - l);
630
631 return repsep_snprintf(bf, size, "%-*s", width, out);
632 }
633
634 static int64_t
635 sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
636 {
637 union perf_mem_data_src data_src_l;
638 union perf_mem_data_src data_src_r;
639
640 if (left->mem_info)
641 data_src_l = left->mem_info->data_src;
642 else
643 data_src_l.mem_lvl = PERF_MEM_LVL_NA;
644
645 if (right->mem_info)
646 data_src_r = right->mem_info->data_src;
647 else
648 data_src_r.mem_lvl = PERF_MEM_LVL_NA;
649
650 return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
651 }
652
653 static const char * const mem_lvl[] = {
654 "N/A",
655 "HIT",
656 "MISS",
657 "L1",
658 "LFB",
659 "L2",
660 "L3",
661 "Local RAM",
662 "Remote RAM (1 hop)",
663 "Remote RAM (2 hops)",
664 "Remote Cache (1 hop)",
665 "Remote Cache (2 hops)",
666 "I/O",
667 "Uncached",
668 };
669 #define NUM_MEM_LVL (sizeof(mem_lvl)/sizeof(const char *))
670
671 static int hist_entry__lvl_snprintf(struct hist_entry *self, char *bf,
672 size_t size, unsigned int width)
673 {
674 char out[64];
675 size_t sz = sizeof(out) - 1; /* -1 for null termination */
676 size_t i, l = 0;
677 u64 m = PERF_MEM_LVL_NA;
678 u64 hit, miss;
679
680 if (self->mem_info)
681 m = self->mem_info->data_src.mem_lvl;
682
683 out[0] = '\0';
684
685 hit = m & PERF_MEM_LVL_HIT;
686 miss = m & PERF_MEM_LVL_MISS;
687
688 /* already taken care of */
689 m &= ~(PERF_MEM_LVL_HIT|PERF_MEM_LVL_MISS);
690
691 for (i = 0; m && i < NUM_MEM_LVL; i++, m >>= 1) {
692 if (!(m & 0x1))
693 continue;
694 if (l) {
695 strcat(out, " or ");
696 l += 4;
697 }
698 strncat(out, mem_lvl[i], sz - l);
699 l += strlen(mem_lvl[i]);
700 }
701 if (*out == '\0')
702 strcpy(out, "N/A");
703 if (hit)
704 strncat(out, " hit", sz - l);
705 if (miss)
706 strncat(out, " miss", sz - l);
707
708 return repsep_snprintf(bf, size, "%-*s", width, out);
709 }
710
711 static int64_t
712 sort__snoop_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_snoop = PERF_MEM_SNOOP_NA;
721
722 if (right->mem_info)
723 data_src_r = right->mem_info->data_src;
724 else
725 data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
726
727 return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
728 }
729
730 static const char * const snoop_access[] = {
731 "N/A",
732 "None",
733 "Miss",
734 "Hit",
735 "HitM",
736 };
737 #define NUM_SNOOP_ACCESS (sizeof(snoop_access)/sizeof(const char *))
738
739 static int hist_entry__snoop_snprintf(struct hist_entry *self, char *bf,
740 size_t size, unsigned int width)
741 {
742 char out[64];
743 size_t sz = sizeof(out) - 1; /* -1 for null termination */
744 size_t i, l = 0;
745 u64 m = PERF_MEM_SNOOP_NA;
746
747 out[0] = '\0';
748
749 if (self->mem_info)
750 m = self->mem_info->data_src.mem_snoop;
751
752 for (i = 0; m && i < NUM_SNOOP_ACCESS; i++, m >>= 1) {
753 if (!(m & 0x1))
754 continue;
755 if (l) {
756 strcat(out, " or ");
757 l += 4;
758 }
759 strncat(out, snoop_access[i], sz - l);
760 l += strlen(snoop_access[i]);
761 }
762
763 if (*out == '\0')
764 strcpy(out, "N/A");
765
766 return repsep_snprintf(bf, size, "%-*s", width, out);
767 }
768
769 struct sort_entry sort_mispredict = {
770 .se_header = "Branch Mispredicted",
771 .se_cmp = sort__mispredict_cmp,
772 .se_snprintf = hist_entry__mispredict_snprintf,
773 .se_width_idx = HISTC_MISPREDICT,
774 };
775
776 static u64 he_weight(struct hist_entry *he)
777 {
778 return he->stat.nr_events ? he->stat.weight / he->stat.nr_events : 0;
779 }
780
781 static int64_t
782 sort__local_weight_cmp(struct hist_entry *left, struct hist_entry *right)
783 {
784 return he_weight(left) - he_weight(right);
785 }
786
787 static int hist_entry__local_weight_snprintf(struct hist_entry *self, char *bf,
788 size_t size, unsigned int width)
789 {
790 return repsep_snprintf(bf, size, "%-*llu", width, he_weight(self));
791 }
792
793 struct sort_entry sort_local_weight = {
794 .se_header = "Local Weight",
795 .se_cmp = sort__local_weight_cmp,
796 .se_snprintf = hist_entry__local_weight_snprintf,
797 .se_width_idx = HISTC_LOCAL_WEIGHT,
798 };
799
800 static int64_t
801 sort__global_weight_cmp(struct hist_entry *left, struct hist_entry *right)
802 {
803 return left->stat.weight - right->stat.weight;
804 }
805
806 static int hist_entry__global_weight_snprintf(struct hist_entry *self, char *bf,
807 size_t size, unsigned int width)
808 {
809 return repsep_snprintf(bf, size, "%-*llu", width, self->stat.weight);
810 }
811
812 struct sort_entry sort_global_weight = {
813 .se_header = "Weight",
814 .se_cmp = sort__global_weight_cmp,
815 .se_snprintf = hist_entry__global_weight_snprintf,
816 .se_width_idx = HISTC_GLOBAL_WEIGHT,
817 };
818
819 struct sort_entry sort_mem_daddr_sym = {
820 .se_header = "Data Symbol",
821 .se_cmp = sort__daddr_cmp,
822 .se_snprintf = hist_entry__daddr_snprintf,
823 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
824 };
825
826 struct sort_entry sort_mem_daddr_dso = {
827 .se_header = "Data Object",
828 .se_cmp = sort__dso_daddr_cmp,
829 .se_snprintf = hist_entry__dso_daddr_snprintf,
830 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
831 };
832
833 struct sort_entry sort_mem_locked = {
834 .se_header = "Locked",
835 .se_cmp = sort__locked_cmp,
836 .se_snprintf = hist_entry__locked_snprintf,
837 .se_width_idx = HISTC_MEM_LOCKED,
838 };
839
840 struct sort_entry sort_mem_tlb = {
841 .se_header = "TLB access",
842 .se_cmp = sort__tlb_cmp,
843 .se_snprintf = hist_entry__tlb_snprintf,
844 .se_width_idx = HISTC_MEM_TLB,
845 };
846
847 struct sort_entry sort_mem_lvl = {
848 .se_header = "Memory access",
849 .se_cmp = sort__lvl_cmp,
850 .se_snprintf = hist_entry__lvl_snprintf,
851 .se_width_idx = HISTC_MEM_LVL,
852 };
853
854 struct sort_entry sort_mem_snoop = {
855 .se_header = "Snoop",
856 .se_cmp = sort__snoop_cmp,
857 .se_snprintf = hist_entry__snoop_snprintf,
858 .se_width_idx = HISTC_MEM_SNOOP,
859 };
860
861 struct sort_dimension {
862 const char *name;
863 struct sort_entry *entry;
864 int taken;
865 };
866
867 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
868
869 static struct sort_dimension common_sort_dimensions[] = {
870 DIM(SORT_PID, "pid", sort_thread),
871 DIM(SORT_COMM, "comm", sort_comm),
872 DIM(SORT_DSO, "dso", sort_dso),
873 DIM(SORT_SYM, "symbol", sort_sym),
874 DIM(SORT_PARENT, "parent", sort_parent),
875 DIM(SORT_CPU, "cpu", sort_cpu),
876 DIM(SORT_SRCLINE, "srcline", sort_srcline),
877 DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
878 DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
879 };
880
881 #undef DIM
882
883 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
884
885 static struct sort_dimension bstack_sort_dimensions[] = {
886 DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
887 DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
888 DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
889 DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
890 DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
891 };
892
893 #undef DIM
894
895 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
896
897 static struct sort_dimension memory_sort_dimensions[] = {
898 DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
899 DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
900 DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
901 DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
902 DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
903 DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
904 };
905
906 #undef DIM
907
908 static void __sort_dimension__add(struct sort_dimension *sd, enum sort_type idx)
909 {
910 if (sd->taken)
911 return;
912
913 if (sd->entry->se_collapse)
914 sort__need_collapse = 1;
915
916 if (list_empty(&hist_entry__sort_list))
917 sort__first_dimension = idx;
918
919 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
920 sd->taken = 1;
921 }
922
923 int sort_dimension__add(const char *tok)
924 {
925 unsigned int i;
926
927 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
928 struct sort_dimension *sd = &common_sort_dimensions[i];
929
930 if (strncasecmp(tok, sd->name, strlen(tok)))
931 continue;
932
933 if (sd->entry == &sort_parent) {
934 int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
935 if (ret) {
936 char err[BUFSIZ];
937
938 regerror(ret, &parent_regex, err, sizeof(err));
939 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
940 return -EINVAL;
941 }
942 sort__has_parent = 1;
943 } else if (sd->entry == &sort_sym) {
944 sort__has_sym = 1;
945 }
946
947 __sort_dimension__add(sd, i);
948 return 0;
949 }
950
951 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
952 struct sort_dimension *sd = &bstack_sort_dimensions[i];
953
954 if (strncasecmp(tok, sd->name, strlen(tok)))
955 continue;
956
957 if (sort__mode != SORT_MODE__BRANCH)
958 return -EINVAL;
959
960 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
961 sort__has_sym = 1;
962
963 __sort_dimension__add(sd, i + __SORT_BRANCH_STACK);
964 return 0;
965 }
966
967 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
968 struct sort_dimension *sd = &memory_sort_dimensions[i];
969
970 if (strncasecmp(tok, sd->name, strlen(tok)))
971 continue;
972
973 if (sort__mode != SORT_MODE__MEMORY)
974 return -EINVAL;
975
976 if (sd->entry == &sort_mem_daddr_sym)
977 sort__has_sym = 1;
978
979 __sort_dimension__add(sd, i + __SORT_MEMORY_MODE);
980 return 0;
981 }
982
983 return -ESRCH;
984 }
985
986 int setup_sorting(void)
987 {
988 char *tmp, *tok, *str = strdup(sort_order);
989 int ret = 0;
990
991 if (str == NULL) {
992 error("Not enough memory to setup sort keys");
993 return -ENOMEM;
994 }
995
996 for (tok = strtok_r(str, ", ", &tmp);
997 tok; tok = strtok_r(NULL, ", ", &tmp)) {
998 ret = sort_dimension__add(tok);
999 if (ret == -EINVAL) {
1000 error("Invalid --sort key: `%s'", tok);
1001 break;
1002 } else if (ret == -ESRCH) {
1003 error("Unknown --sort key: `%s'", tok);
1004 break;
1005 }
1006 }
1007
1008 free(str);
1009 return ret;
1010 }
1011
1012 static void sort_entry__setup_elide(struct sort_entry *self,
1013 struct strlist *list,
1014 const char *list_name, FILE *fp)
1015 {
1016 if (list && strlist__nr_entries(list) == 1) {
1017 if (fp != NULL)
1018 fprintf(fp, "# %s: %s\n", list_name,
1019 strlist__entry(list, 0)->s);
1020 self->elide = true;
1021 }
1022 }
1023
1024 void sort__setup_elide(FILE *output)
1025 {
1026 sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
1027 "dso", output);
1028 sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list,
1029 "comm", output);
1030 sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list,
1031 "symbol", output);
1032
1033 if (sort__mode == SORT_MODE__BRANCH) {
1034 sort_entry__setup_elide(&sort_dso_from,
1035 symbol_conf.dso_from_list,
1036 "dso_from", output);
1037 sort_entry__setup_elide(&sort_dso_to,
1038 symbol_conf.dso_to_list,
1039 "dso_to", output);
1040 sort_entry__setup_elide(&sort_sym_from,
1041 symbol_conf.sym_from_list,
1042 "sym_from", output);
1043 sort_entry__setup_elide(&sort_sym_to,
1044 symbol_conf.sym_to_list,
1045 "sym_to", output);
1046 } else if (sort__mode == SORT_MODE__MEMORY) {
1047 sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
1048 "symbol_daddr", output);
1049 sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
1050 "dso_daddr", output);
1051 sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
1052 "mem", output);
1053 sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
1054 "local_weight", output);
1055 sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
1056 "tlb", output);
1057 sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
1058 "snoop", output);
1059 }
1060
1061 }
Linux with added FPC-III support