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 int sort__need_collapse
= 0;
11 int sort__has_parent
= 0;
12 int sort__has_sym
= 0;
13 enum sort_mode sort__mode
= SORT_MODE__NORMAL
;
15 enum sort_type sort__first_dimension
;
17 LIST_HEAD(hist_entry__sort_list
);
19 static int repsep_snprintf(char *bf
, size_t size
, const char *fmt
, ...)
25 n
= vsnprintf(bf
, size
, fmt
, ap
);
26 if (symbol_conf
.field_sep
&& n
> 0) {
30 sep
= strchr(sep
, *symbol_conf
.field_sep
);
43 static int64_t cmp_null(void *l
, void *r
)
56 sort__thread_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
58 return right
->thread
->tid
- left
->thread
->tid
;
61 static int hist_entry__thread_snprintf(struct hist_entry
*self
, char *bf
,
62 size_t size
, unsigned int width
)
64 return repsep_snprintf(bf
, size
, "%*s:%5d", width
- 6,
65 self
->thread
->comm
?: "", self
->thread
->tid
);
68 struct sort_entry sort_thread
= {
69 .se_header
= "Command: Pid",
70 .se_cmp
= sort__thread_cmp
,
71 .se_snprintf
= hist_entry__thread_snprintf
,
72 .se_width_idx
= HISTC_THREAD
,
78 sort__comm_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
80 return right
->thread
->tid
- left
->thread
->tid
;
84 sort__comm_collapse(struct hist_entry
*left
, struct hist_entry
*right
)
86 char *comm_l
= left
->thread
->comm
;
87 char *comm_r
= right
->thread
->comm
;
89 if (!comm_l
|| !comm_r
)
90 return cmp_null(comm_l
, comm_r
);
92 return strcmp(comm_l
, comm_r
);
95 static int hist_entry__comm_snprintf(struct hist_entry
*self
, char *bf
,
96 size_t size
, unsigned int width
)
98 return repsep_snprintf(bf
, size
, "%*s", width
, self
->thread
->comm
);
101 struct sort_entry sort_comm
= {
102 .se_header
= "Command",
103 .se_cmp
= sort__comm_cmp
,
104 .se_collapse
= sort__comm_collapse
,
105 .se_snprintf
= hist_entry__comm_snprintf
,
106 .se_width_idx
= HISTC_COMM
,
111 static int64_t _sort__dso_cmp(struct map
*map_l
, struct map
*map_r
)
113 struct dso
*dso_l
= map_l
? map_l
->dso
: NULL
;
114 struct dso
*dso_r
= map_r
? map_r
->dso
: NULL
;
115 const char *dso_name_l
, *dso_name_r
;
117 if (!dso_l
|| !dso_r
)
118 return cmp_null(dso_l
, dso_r
);
121 dso_name_l
= dso_l
->long_name
;
122 dso_name_r
= dso_r
->long_name
;
124 dso_name_l
= dso_l
->short_name
;
125 dso_name_r
= dso_r
->short_name
;
128 return strcmp(dso_name_l
, dso_name_r
);
132 sort__dso_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
134 return _sort__dso_cmp(left
->ms
.map
, right
->ms
.map
);
137 static int _hist_entry__dso_snprintf(struct map
*map
, char *bf
,
138 size_t size
, unsigned int width
)
140 if (map
&& map
->dso
) {
141 const char *dso_name
= !verbose
? map
->dso
->short_name
:
143 return repsep_snprintf(bf
, size
, "%-*s", width
, dso_name
);
146 return repsep_snprintf(bf
, size
, "%-*s", width
, "[unknown]");
149 static int hist_entry__dso_snprintf(struct hist_entry
*self
, char *bf
,
150 size_t size
, unsigned int width
)
152 return _hist_entry__dso_snprintf(self
->ms
.map
, bf
, size
, width
);
155 struct sort_entry sort_dso
= {
156 .se_header
= "Shared Object",
157 .se_cmp
= sort__dso_cmp
,
158 .se_snprintf
= hist_entry__dso_snprintf
,
159 .se_width_idx
= HISTC_DSO
,
164 static int64_t _sort__sym_cmp(struct symbol
*sym_l
, struct symbol
*sym_r
)
168 if (!sym_l
|| !sym_r
)
169 return cmp_null(sym_l
, sym_r
);
177 return (int64_t)(ip_r
- ip_l
);
181 sort__sym_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
183 if (!left
->ms
.sym
&& !right
->ms
.sym
)
184 return right
->level
- left
->level
;
186 return _sort__sym_cmp(left
->ms
.sym
, right
->ms
.sym
);
189 static int _hist_entry__sym_snprintf(struct map
*map
, struct symbol
*sym
,
190 u64 ip
, char level
, char *bf
, size_t size
,
196 char o
= map
? dso__symtab_origin(map
->dso
) : '!';
197 ret
+= repsep_snprintf(bf
, size
, "%-#*llx %c ",
198 BITS_PER_LONG
/ 4 + 2, ip
, o
);
201 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "[%c] ", level
);
203 if (map
->type
== MAP__VARIABLE
) {
204 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%s", sym
->name
);
205 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "+0x%llx",
206 ip
- map
->unmap_ip(map
, sym
->start
));
207 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%-*s",
210 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%-*s",
215 size_t len
= BITS_PER_LONG
/ 4;
216 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%-#.*llx",
218 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%-*s",
225 static int hist_entry__sym_snprintf(struct hist_entry
*self
, char *bf
,
226 size_t size
, unsigned int width
)
228 return _hist_entry__sym_snprintf(self
->ms
.map
, self
->ms
.sym
, self
->ip
,
229 self
->level
, bf
, size
, width
);
232 struct sort_entry sort_sym
= {
233 .se_header
= "Symbol",
234 .se_cmp
= sort__sym_cmp
,
235 .se_snprintf
= hist_entry__sym_snprintf
,
236 .se_width_idx
= HISTC_SYMBOL
,
242 sort__srcline_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
244 return (int64_t)(right
->ip
- left
->ip
);
247 static int hist_entry__srcline_snprintf(struct hist_entry
*self
, char *bf
,
249 unsigned int width __maybe_unused
)
252 char cmd
[PATH_MAX
+ 2], *path
= self
->srcline
, *nl
;
261 if (!strncmp(self
->ms
.map
->dso
->long_name
, "/tmp/perf-", 10))
264 snprintf(cmd
, sizeof(cmd
), "addr2line -e %s %016" PRIx64
,
265 self
->ms
.map
->dso
->long_name
, self
->ip
);
266 fp
= popen(cmd
, "r");
270 if (getline(&path
, &line_len
, fp
) < 0 || !line_len
)
272 self
->srcline
= strdup(path
);
273 if (self
->srcline
== NULL
)
276 nl
= strchr(self
->srcline
, '\n');
279 path
= self
->srcline
;
283 return repsep_snprintf(bf
, size
, "%s", path
);
287 return repsep_snprintf(bf
, size
, "%-#*llx", BITS_PER_LONG
/ 4, self
->ip
);
290 struct sort_entry sort_srcline
= {
291 .se_header
= "Source:Line",
292 .se_cmp
= sort__srcline_cmp
,
293 .se_snprintf
= hist_entry__srcline_snprintf
,
294 .se_width_idx
= HISTC_SRCLINE
,
300 sort__parent_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
302 struct symbol
*sym_l
= left
->parent
;
303 struct symbol
*sym_r
= right
->parent
;
305 if (!sym_l
|| !sym_r
)
306 return cmp_null(sym_l
, sym_r
);
308 return strcmp(sym_l
->name
, sym_r
->name
);
311 static int hist_entry__parent_snprintf(struct hist_entry
*self
, char *bf
,
312 size_t size
, unsigned int width
)
314 return repsep_snprintf(bf
, size
, "%-*s", width
,
315 self
->parent
? self
->parent
->name
: "[other]");
318 struct sort_entry sort_parent
= {
319 .se_header
= "Parent symbol",
320 .se_cmp
= sort__parent_cmp
,
321 .se_snprintf
= hist_entry__parent_snprintf
,
322 .se_width_idx
= HISTC_PARENT
,
328 sort__cpu_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
330 return right
->cpu
- left
->cpu
;
333 static int hist_entry__cpu_snprintf(struct hist_entry
*self
, char *bf
,
334 size_t size
, unsigned int width
)
336 return repsep_snprintf(bf
, size
, "%*d", width
, self
->cpu
);
339 struct sort_entry sort_cpu
= {
341 .se_cmp
= sort__cpu_cmp
,
342 .se_snprintf
= hist_entry__cpu_snprintf
,
343 .se_width_idx
= HISTC_CPU
,
346 /* sort keys for branch stacks */
349 sort__dso_from_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
351 return _sort__dso_cmp(left
->branch_info
->from
.map
,
352 right
->branch_info
->from
.map
);
355 static int hist_entry__dso_from_snprintf(struct hist_entry
*self
, char *bf
,
356 size_t size
, unsigned int width
)
358 return _hist_entry__dso_snprintf(self
->branch_info
->from
.map
,
363 sort__dso_to_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
365 return _sort__dso_cmp(left
->branch_info
->to
.map
,
366 right
->branch_info
->to
.map
);
369 static int hist_entry__dso_to_snprintf(struct hist_entry
*self
, char *bf
,
370 size_t size
, unsigned int width
)
372 return _hist_entry__dso_snprintf(self
->branch_info
->to
.map
,
377 sort__sym_from_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
379 struct addr_map_symbol
*from_l
= &left
->branch_info
->from
;
380 struct addr_map_symbol
*from_r
= &right
->branch_info
->from
;
382 if (!from_l
->sym
&& !from_r
->sym
)
383 return right
->level
- left
->level
;
385 return _sort__sym_cmp(from_l
->sym
, from_r
->sym
);
389 sort__sym_to_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
391 struct addr_map_symbol
*to_l
= &left
->branch_info
->to
;
392 struct addr_map_symbol
*to_r
= &right
->branch_info
->to
;
394 if (!to_l
->sym
&& !to_r
->sym
)
395 return right
->level
- left
->level
;
397 return _sort__sym_cmp(to_l
->sym
, to_r
->sym
);
400 static int hist_entry__sym_from_snprintf(struct hist_entry
*self
, char *bf
,
401 size_t size
, unsigned int width
)
403 struct addr_map_symbol
*from
= &self
->branch_info
->from
;
404 return _hist_entry__sym_snprintf(from
->map
, from
->sym
, from
->addr
,
405 self
->level
, bf
, size
, width
);
409 static int hist_entry__sym_to_snprintf(struct hist_entry
*self
, char *bf
,
410 size_t size
, unsigned int width
)
412 struct addr_map_symbol
*to
= &self
->branch_info
->to
;
413 return _hist_entry__sym_snprintf(to
->map
, to
->sym
, to
->addr
,
414 self
->level
, bf
, size
, width
);
418 struct sort_entry sort_dso_from
= {
419 .se_header
= "Source Shared Object",
420 .se_cmp
= sort__dso_from_cmp
,
421 .se_snprintf
= hist_entry__dso_from_snprintf
,
422 .se_width_idx
= HISTC_DSO_FROM
,
425 struct sort_entry sort_dso_to
= {
426 .se_header
= "Target Shared Object",
427 .se_cmp
= sort__dso_to_cmp
,
428 .se_snprintf
= hist_entry__dso_to_snprintf
,
429 .se_width_idx
= HISTC_DSO_TO
,
432 struct sort_entry sort_sym_from
= {
433 .se_header
= "Source Symbol",
434 .se_cmp
= sort__sym_from_cmp
,
435 .se_snprintf
= hist_entry__sym_from_snprintf
,
436 .se_width_idx
= HISTC_SYMBOL_FROM
,
439 struct sort_entry sort_sym_to
= {
440 .se_header
= "Target Symbol",
441 .se_cmp
= sort__sym_to_cmp
,
442 .se_snprintf
= hist_entry__sym_to_snprintf
,
443 .se_width_idx
= HISTC_SYMBOL_TO
,
447 sort__mispredict_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
449 const unsigned char mp
= left
->branch_info
->flags
.mispred
!=
450 right
->branch_info
->flags
.mispred
;
451 const unsigned char p
= left
->branch_info
->flags
.predicted
!=
452 right
->branch_info
->flags
.predicted
;
457 static int hist_entry__mispredict_snprintf(struct hist_entry
*self
, char *bf
,
458 size_t size
, unsigned int width
){
459 static const char *out
= "N/A";
461 if (self
->branch_info
->flags
.predicted
)
463 else if (self
->branch_info
->flags
.mispred
)
466 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
469 /* --sort daddr_sym */
471 sort__daddr_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
473 uint64_t l
= 0, r
= 0;
476 l
= left
->mem_info
->daddr
.addr
;
478 r
= right
->mem_info
->daddr
.addr
;
480 return (int64_t)(r
- l
);
483 static int hist_entry__daddr_snprintf(struct hist_entry
*self
, char *bf
,
484 size_t size
, unsigned int width
)
487 struct map
*map
= NULL
;
488 struct symbol
*sym
= NULL
;
490 if (self
->mem_info
) {
491 addr
= self
->mem_info
->daddr
.addr
;
492 map
= self
->mem_info
->daddr
.map
;
493 sym
= self
->mem_info
->daddr
.sym
;
495 return _hist_entry__sym_snprintf(map
, sym
, addr
, self
->level
, bf
, size
,
500 sort__dso_daddr_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
502 struct map
*map_l
= NULL
;
503 struct map
*map_r
= NULL
;
506 map_l
= left
->mem_info
->daddr
.map
;
508 map_r
= right
->mem_info
->daddr
.map
;
510 return _sort__dso_cmp(map_l
, map_r
);
513 static int hist_entry__dso_daddr_snprintf(struct hist_entry
*self
, char *bf
,
514 size_t size
, unsigned int width
)
516 struct map
*map
= NULL
;
519 map
= self
->mem_info
->daddr
.map
;
521 return _hist_entry__dso_snprintf(map
, bf
, size
, width
);
525 sort__locked_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
527 union perf_mem_data_src data_src_l
;
528 union perf_mem_data_src data_src_r
;
531 data_src_l
= left
->mem_info
->data_src
;
533 data_src_l
.mem_lock
= PERF_MEM_LOCK_NA
;
536 data_src_r
= right
->mem_info
->data_src
;
538 data_src_r
.mem_lock
= PERF_MEM_LOCK_NA
;
540 return (int64_t)(data_src_r
.mem_lock
- data_src_l
.mem_lock
);
543 static int hist_entry__locked_snprintf(struct hist_entry
*self
, char *bf
,
544 size_t size
, unsigned int width
)
547 u64 mask
= PERF_MEM_LOCK_NA
;
550 mask
= self
->mem_info
->data_src
.mem_lock
;
552 if (mask
& PERF_MEM_LOCK_NA
)
554 else if (mask
& PERF_MEM_LOCK_LOCKED
)
559 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
563 sort__tlb_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
565 union perf_mem_data_src data_src_l
;
566 union perf_mem_data_src data_src_r
;
569 data_src_l
= left
->mem_info
->data_src
;
571 data_src_l
.mem_dtlb
= PERF_MEM_TLB_NA
;
574 data_src_r
= right
->mem_info
->data_src
;
576 data_src_r
.mem_dtlb
= PERF_MEM_TLB_NA
;
578 return (int64_t)(data_src_r
.mem_dtlb
- data_src_l
.mem_dtlb
);
581 static const char * const tlb_access
[] = {
590 #define NUM_TLB_ACCESS (sizeof(tlb_access)/sizeof(const char *))
592 static int hist_entry__tlb_snprintf(struct hist_entry
*self
, char *bf
,
593 size_t size
, unsigned int width
)
596 size_t sz
= sizeof(out
) - 1; /* -1 for null termination */
598 u64 m
= PERF_MEM_TLB_NA
;
604 m
= self
->mem_info
->data_src
.mem_dtlb
;
606 hit
= m
& PERF_MEM_TLB_HIT
;
607 miss
= m
& PERF_MEM_TLB_MISS
;
609 /* already taken care of */
610 m
&= ~(PERF_MEM_TLB_HIT
|PERF_MEM_TLB_MISS
);
612 for (i
= 0; m
&& i
< NUM_TLB_ACCESS
; i
++, m
>>= 1) {
619 strncat(out
, tlb_access
[i
], sz
- l
);
620 l
+= strlen(tlb_access
[i
]);
625 strncat(out
, " hit", sz
- l
);
627 strncat(out
, " miss", sz
- l
);
629 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
633 sort__lvl_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
635 union perf_mem_data_src data_src_l
;
636 union perf_mem_data_src data_src_r
;
639 data_src_l
= left
->mem_info
->data_src
;
641 data_src_l
.mem_lvl
= PERF_MEM_LVL_NA
;
644 data_src_r
= right
->mem_info
->data_src
;
646 data_src_r
.mem_lvl
= PERF_MEM_LVL_NA
;
648 return (int64_t)(data_src_r
.mem_lvl
- data_src_l
.mem_lvl
);
651 static const char * const mem_lvl
[] = {
660 "Remote RAM (1 hop)",
661 "Remote RAM (2 hops)",
662 "Remote Cache (1 hop)",
663 "Remote Cache (2 hops)",
667 #define NUM_MEM_LVL (sizeof(mem_lvl)/sizeof(const char *))
669 static int hist_entry__lvl_snprintf(struct hist_entry
*self
, char *bf
,
670 size_t size
, unsigned int width
)
673 size_t sz
= sizeof(out
) - 1; /* -1 for null termination */
675 u64 m
= PERF_MEM_LVL_NA
;
679 m
= self
->mem_info
->data_src
.mem_lvl
;
683 hit
= m
& PERF_MEM_LVL_HIT
;
684 miss
= m
& PERF_MEM_LVL_MISS
;
686 /* already taken care of */
687 m
&= ~(PERF_MEM_LVL_HIT
|PERF_MEM_LVL_MISS
);
689 for (i
= 0; m
&& i
< NUM_MEM_LVL
; i
++, m
>>= 1) {
696 strncat(out
, mem_lvl
[i
], sz
- l
);
697 l
+= strlen(mem_lvl
[i
]);
702 strncat(out
, " hit", sz
- l
);
704 strncat(out
, " miss", sz
- l
);
706 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
710 sort__snoop_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
712 union perf_mem_data_src data_src_l
;
713 union perf_mem_data_src data_src_r
;
716 data_src_l
= left
->mem_info
->data_src
;
718 data_src_l
.mem_snoop
= PERF_MEM_SNOOP_NA
;
721 data_src_r
= right
->mem_info
->data_src
;
723 data_src_r
.mem_snoop
= PERF_MEM_SNOOP_NA
;
725 return (int64_t)(data_src_r
.mem_snoop
- data_src_l
.mem_snoop
);
728 static const char * const snoop_access
[] = {
735 #define NUM_SNOOP_ACCESS (sizeof(snoop_access)/sizeof(const char *))
737 static int hist_entry__snoop_snprintf(struct hist_entry
*self
, char *bf
,
738 size_t size
, unsigned int width
)
741 size_t sz
= sizeof(out
) - 1; /* -1 for null termination */
743 u64 m
= PERF_MEM_SNOOP_NA
;
748 m
= self
->mem_info
->data_src
.mem_snoop
;
750 for (i
= 0; m
&& i
< NUM_SNOOP_ACCESS
; i
++, m
>>= 1) {
757 strncat(out
, snoop_access
[i
], sz
- l
);
758 l
+= strlen(snoop_access
[i
]);
764 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
767 struct sort_entry sort_mispredict
= {
768 .se_header
= "Branch Mispredicted",
769 .se_cmp
= sort__mispredict_cmp
,
770 .se_snprintf
= hist_entry__mispredict_snprintf
,
771 .se_width_idx
= HISTC_MISPREDICT
,
774 static u64
he_weight(struct hist_entry
*he
)
776 return he
->stat
.nr_events
? he
->stat
.weight
/ he
->stat
.nr_events
: 0;
780 sort__local_weight_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
782 return he_weight(left
) - he_weight(right
);
785 static int hist_entry__local_weight_snprintf(struct hist_entry
*self
, char *bf
,
786 size_t size
, unsigned int width
)
788 return repsep_snprintf(bf
, size
, "%-*llu", width
, he_weight(self
));
791 struct sort_entry sort_local_weight
= {
792 .se_header
= "Local Weight",
793 .se_cmp
= sort__local_weight_cmp
,
794 .se_snprintf
= hist_entry__local_weight_snprintf
,
795 .se_width_idx
= HISTC_LOCAL_WEIGHT
,
799 sort__global_weight_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
801 return left
->stat
.weight
- right
->stat
.weight
;
804 static int hist_entry__global_weight_snprintf(struct hist_entry
*self
, char *bf
,
805 size_t size
, unsigned int width
)
807 return repsep_snprintf(bf
, size
, "%-*llu", width
, self
->stat
.weight
);
810 struct sort_entry sort_global_weight
= {
811 .se_header
= "Weight",
812 .se_cmp
= sort__global_weight_cmp
,
813 .se_snprintf
= hist_entry__global_weight_snprintf
,
814 .se_width_idx
= HISTC_GLOBAL_WEIGHT
,
817 struct sort_entry sort_mem_daddr_sym
= {
818 .se_header
= "Data Symbol",
819 .se_cmp
= sort__daddr_cmp
,
820 .se_snprintf
= hist_entry__daddr_snprintf
,
821 .se_width_idx
= HISTC_MEM_DADDR_SYMBOL
,
824 struct sort_entry sort_mem_daddr_dso
= {
825 .se_header
= "Data Object",
826 .se_cmp
= sort__dso_daddr_cmp
,
827 .se_snprintf
= hist_entry__dso_daddr_snprintf
,
828 .se_width_idx
= HISTC_MEM_DADDR_SYMBOL
,
831 struct sort_entry sort_mem_locked
= {
832 .se_header
= "Locked",
833 .se_cmp
= sort__locked_cmp
,
834 .se_snprintf
= hist_entry__locked_snprintf
,
835 .se_width_idx
= HISTC_MEM_LOCKED
,
838 struct sort_entry sort_mem_tlb
= {
839 .se_header
= "TLB access",
840 .se_cmp
= sort__tlb_cmp
,
841 .se_snprintf
= hist_entry__tlb_snprintf
,
842 .se_width_idx
= HISTC_MEM_TLB
,
845 struct sort_entry sort_mem_lvl
= {
846 .se_header
= "Memory access",
847 .se_cmp
= sort__lvl_cmp
,
848 .se_snprintf
= hist_entry__lvl_snprintf
,
849 .se_width_idx
= HISTC_MEM_LVL
,
852 struct sort_entry sort_mem_snoop
= {
853 .se_header
= "Snoop",
854 .se_cmp
= sort__snoop_cmp
,
855 .se_snprintf
= hist_entry__snoop_snprintf
,
856 .se_width_idx
= HISTC_MEM_SNOOP
,
859 struct sort_dimension
{
861 struct sort_entry
*entry
;
865 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
867 static struct sort_dimension common_sort_dimensions
[] = {
868 DIM(SORT_PID
, "pid", sort_thread
),
869 DIM(SORT_COMM
, "comm", sort_comm
),
870 DIM(SORT_DSO
, "dso", sort_dso
),
871 DIM(SORT_SYM
, "symbol", sort_sym
),
872 DIM(SORT_PARENT
, "parent", sort_parent
),
873 DIM(SORT_CPU
, "cpu", sort_cpu
),
874 DIM(SORT_SRCLINE
, "srcline", sort_srcline
),
879 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
881 static struct sort_dimension bstack_sort_dimensions
[] = {
882 DIM(SORT_DSO_FROM
, "dso_from", sort_dso_from
),
883 DIM(SORT_DSO_TO
, "dso_to", sort_dso_to
),
884 DIM(SORT_SYM_FROM
, "symbol_from", sort_sym_from
),
885 DIM(SORT_SYM_TO
, "symbol_to", sort_sym_to
),
886 DIM(SORT_MISPREDICT
, "mispredict", sort_mispredict
),
891 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
893 static struct sort_dimension memory_sort_dimensions
[] = {
894 DIM(SORT_LOCAL_WEIGHT
, "local_weight", sort_local_weight
),
895 DIM(SORT_GLOBAL_WEIGHT
, "weight", sort_global_weight
),
896 DIM(SORT_MEM_DADDR_SYMBOL
, "symbol_daddr", sort_mem_daddr_sym
),
897 DIM(SORT_MEM_DADDR_DSO
, "dso_daddr", sort_mem_daddr_dso
),
898 DIM(SORT_MEM_LOCKED
, "locked", sort_mem_locked
),
899 DIM(SORT_MEM_TLB
, "tlb", sort_mem_tlb
),
900 DIM(SORT_MEM_LVL
, "mem", sort_mem_lvl
),
901 DIM(SORT_MEM_SNOOP
, "snoop", sort_mem_snoop
),
906 static void __sort_dimension__add(struct sort_dimension
*sd
, enum sort_type idx
)
911 if (sd
->entry
->se_collapse
)
912 sort__need_collapse
= 1;
914 if (list_empty(&hist_entry__sort_list
))
915 sort__first_dimension
= idx
;
917 list_add_tail(&sd
->entry
->list
, &hist_entry__sort_list
);
921 int sort_dimension__add(const char *tok
)
925 for (i
= 0; i
< ARRAY_SIZE(common_sort_dimensions
); i
++) {
926 struct sort_dimension
*sd
= &common_sort_dimensions
[i
];
928 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
931 if (sd
->entry
== &sort_parent
) {
932 int ret
= regcomp(&parent_regex
, parent_pattern
, REG_EXTENDED
);
936 regerror(ret
, &parent_regex
, err
, sizeof(err
));
937 pr_err("Invalid regex: %s\n%s", parent_pattern
, err
);
940 sort__has_parent
= 1;
941 } else if (sd
->entry
== &sort_sym
) {
945 __sort_dimension__add(sd
, i
);
949 for (i
= 0; i
< ARRAY_SIZE(bstack_sort_dimensions
); i
++) {
950 struct sort_dimension
*sd
= &bstack_sort_dimensions
[i
];
952 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
955 if (sort__mode
!= SORT_MODE__BRANCH
)
958 if (sd
->entry
== &sort_sym_from
|| sd
->entry
== &sort_sym_to
)
961 __sort_dimension__add(sd
, i
+ __SORT_BRANCH_STACK
);
965 for (i
= 0; i
< ARRAY_SIZE(memory_sort_dimensions
); i
++) {
966 struct sort_dimension
*sd
= &memory_sort_dimensions
[i
];
968 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
971 if (sort__mode
!= SORT_MODE__MEMORY
)
974 if (sd
->entry
== &sort_mem_daddr_sym
)
977 __sort_dimension__add(sd
, i
+ __SORT_MEMORY_MODE
);
984 int setup_sorting(void)
986 char *tmp
, *tok
, *str
= strdup(sort_order
);
990 error("Not enough memory to setup sort keys");
994 for (tok
= strtok_r(str
, ", ", &tmp
);
995 tok
; tok
= strtok_r(NULL
, ", ", &tmp
)) {
996 ret
= sort_dimension__add(tok
);
997 if (ret
== -EINVAL
) {
998 error("Invalid --sort key: `%s'", tok
);
1000 } else if (ret
== -ESRCH
) {
1001 error("Unknown --sort key: `%s'", tok
);
1010 static void sort_entry__setup_elide(struct sort_entry
*self
,
1011 struct strlist
*list
,
1012 const char *list_name
, FILE *fp
)
1014 if (list
&& strlist__nr_entries(list
) == 1) {
1016 fprintf(fp
, "# %s: %s\n", list_name
,
1017 strlist__entry(list
, 0)->s
);
1022 void sort__setup_elide(FILE *output
)
1024 sort_entry__setup_elide(&sort_dso
, symbol_conf
.dso_list
,
1026 sort_entry__setup_elide(&sort_comm
, symbol_conf
.comm_list
,
1028 sort_entry__setup_elide(&sort_sym
, symbol_conf
.sym_list
,
1031 if (sort__mode
== SORT_MODE__BRANCH
) {
1032 sort_entry__setup_elide(&sort_dso_from
,
1033 symbol_conf
.dso_from_list
,
1034 "dso_from", output
);
1035 sort_entry__setup_elide(&sort_dso_to
,
1036 symbol_conf
.dso_to_list
,
1038 sort_entry__setup_elide(&sort_sym_from
,
1039 symbol_conf
.sym_from_list
,
1040 "sym_from", output
);
1041 sort_entry__setup_elide(&sort_sym_to
,
1042 symbol_conf
.sym_to_list
,
1044 } else if (sort__mode
== SORT_MODE__MEMORY
) {
1045 sort_entry__setup_elide(&sort_dso
, symbol_conf
.dso_list
,
1046 "symbol_daddr", output
);
1047 sort_entry__setup_elide(&sort_dso
, symbol_conf
.dso_list
,
1048 "dso_daddr", output
);
1049 sort_entry__setup_elide(&sort_dso
, symbol_conf
.dso_list
,
1051 sort_entry__setup_elide(&sort_dso
, symbol_conf
.dso_list
,
1052 "local_weight", output
);
1053 sort_entry__setup_elide(&sort_dso
, symbol_conf
.dso_list
,
1055 sort_entry__setup_elide(&sort_dso
, symbol_conf
.dso_list
,