8 #include <traceevent/event-parse.h>
9 #include "mem-events.h"
12 const char default_parent_pattern
[] = "^sys_|^do_page_fault";
13 const char *parent_pattern
= default_parent_pattern
;
14 const char default_sort_order
[] = "comm,dso,symbol";
15 const char default_branch_sort_order
[] = "comm,dso_from,symbol_from,symbol_to,cycles";
16 const char default_mem_sort_order
[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked";
17 const char default_top_sort_order
[] = "dso,symbol";
18 const char default_diff_sort_order
[] = "dso,symbol";
19 const char default_tracepoint_sort_order
[] = "trace";
20 const char *sort_order
;
21 const char *field_order
;
22 regex_t ignore_callees_regex
;
23 int have_ignore_callees
= 0;
24 int sort__need_collapse
= 0;
25 int sort__has_parent
= 0;
26 int sort__has_sym
= 0;
27 int sort__has_dso
= 0;
28 int sort__has_socket
= 0;
29 int sort__has_thread
= 0;
30 enum sort_mode sort__mode
= SORT_MODE__NORMAL
;
33 * Replaces all occurrences of a char used with the:
35 * -t, --field-separator
37 * option, that uses a special separator character and don't pad with spaces,
38 * replacing all occurances of this separator in symbol names (and other
39 * output) with a '.' character, that thus it's the only non valid separator.
41 static int repsep_snprintf(char *bf
, size_t size
, const char *fmt
, ...)
47 n
= vsnprintf(bf
, size
, fmt
, ap
);
48 if (symbol_conf
.field_sep
&& n
> 0) {
52 sep
= strchr(sep
, *symbol_conf
.field_sep
);
65 static int64_t cmp_null(const void *l
, const void *r
)
78 sort__thread_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
80 return right
->thread
->tid
- left
->thread
->tid
;
83 static int hist_entry__thread_snprintf(struct hist_entry
*he
, char *bf
,
84 size_t size
, unsigned int width
)
86 const char *comm
= thread__comm_str(he
->thread
);
88 width
= max(7U, width
) - 6;
89 return repsep_snprintf(bf
, size
, "%5d:%-*.*s", he
->thread
->tid
,
90 width
, width
, comm
?: "");
93 struct sort_entry sort_thread
= {
94 .se_header
= " Pid:Command",
95 .se_cmp
= sort__thread_cmp
,
96 .se_snprintf
= hist_entry__thread_snprintf
,
97 .se_width_idx
= HISTC_THREAD
,
103 sort__comm_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
105 /* Compare the addr that should be unique among comm */
106 return strcmp(comm__str(right
->comm
), comm__str(left
->comm
));
110 sort__comm_collapse(struct hist_entry
*left
, struct hist_entry
*right
)
112 /* Compare the addr that should be unique among comm */
113 return strcmp(comm__str(right
->comm
), comm__str(left
->comm
));
117 sort__comm_sort(struct hist_entry
*left
, struct hist_entry
*right
)
119 return strcmp(comm__str(right
->comm
), comm__str(left
->comm
));
122 static int hist_entry__comm_snprintf(struct hist_entry
*he
, char *bf
,
123 size_t size
, unsigned int width
)
125 return repsep_snprintf(bf
, size
, "%-*.*s", width
, width
, comm__str(he
->comm
));
128 struct sort_entry sort_comm
= {
129 .se_header
= "Command",
130 .se_cmp
= sort__comm_cmp
,
131 .se_collapse
= sort__comm_collapse
,
132 .se_sort
= sort__comm_sort
,
133 .se_snprintf
= hist_entry__comm_snprintf
,
134 .se_width_idx
= HISTC_COMM
,
139 static int64_t _sort__dso_cmp(struct map
*map_l
, struct map
*map_r
)
141 struct dso
*dso_l
= map_l
? map_l
->dso
: NULL
;
142 struct dso
*dso_r
= map_r
? map_r
->dso
: NULL
;
143 const char *dso_name_l
, *dso_name_r
;
145 if (!dso_l
|| !dso_r
)
146 return cmp_null(dso_r
, dso_l
);
149 dso_name_l
= dso_l
->long_name
;
150 dso_name_r
= dso_r
->long_name
;
152 dso_name_l
= dso_l
->short_name
;
153 dso_name_r
= dso_r
->short_name
;
156 return strcmp(dso_name_l
, dso_name_r
);
160 sort__dso_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
162 return _sort__dso_cmp(right
->ms
.map
, left
->ms
.map
);
165 static int _hist_entry__dso_snprintf(struct map
*map
, char *bf
,
166 size_t size
, unsigned int width
)
168 if (map
&& map
->dso
) {
169 const char *dso_name
= !verbose
? map
->dso
->short_name
:
171 return repsep_snprintf(bf
, size
, "%-*.*s", width
, width
, dso_name
);
174 return repsep_snprintf(bf
, size
, "%-*.*s", width
, width
, "[unknown]");
177 static int hist_entry__dso_snprintf(struct hist_entry
*he
, char *bf
,
178 size_t size
, unsigned int width
)
180 return _hist_entry__dso_snprintf(he
->ms
.map
, bf
, size
, width
);
183 struct sort_entry sort_dso
= {
184 .se_header
= "Shared Object",
185 .se_cmp
= sort__dso_cmp
,
186 .se_snprintf
= hist_entry__dso_snprintf
,
187 .se_width_idx
= HISTC_DSO
,
192 static int64_t _sort__addr_cmp(u64 left_ip
, u64 right_ip
)
194 return (int64_t)(right_ip
- left_ip
);
197 static int64_t _sort__sym_cmp(struct symbol
*sym_l
, struct symbol
*sym_r
)
199 if (!sym_l
|| !sym_r
)
200 return cmp_null(sym_l
, sym_r
);
205 if (sym_l
->start
!= sym_r
->start
)
206 return (int64_t)(sym_r
->start
- sym_l
->start
);
208 return (int64_t)(sym_r
->end
- sym_l
->end
);
212 sort__sym_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
216 if (!left
->ms
.sym
&& !right
->ms
.sym
)
217 return _sort__addr_cmp(left
->ip
, right
->ip
);
220 * comparing symbol address alone is not enough since it's a
221 * relative address within a dso.
223 if (!sort__has_dso
) {
224 ret
= sort__dso_cmp(left
, right
);
229 return _sort__sym_cmp(left
->ms
.sym
, right
->ms
.sym
);
233 sort__sym_sort(struct hist_entry
*left
, struct hist_entry
*right
)
235 if (!left
->ms
.sym
|| !right
->ms
.sym
)
236 return cmp_null(left
->ms
.sym
, right
->ms
.sym
);
238 return strcmp(right
->ms
.sym
->name
, left
->ms
.sym
->name
);
241 static int _hist_entry__sym_snprintf(struct map
*map
, struct symbol
*sym
,
242 u64 ip
, char level
, char *bf
, size_t size
,
248 char o
= map
? dso__symtab_origin(map
->dso
) : '!';
249 ret
+= repsep_snprintf(bf
, size
, "%-#*llx %c ",
250 BITS_PER_LONG
/ 4 + 2, ip
, o
);
253 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "[%c] ", level
);
255 if (map
->type
== MAP__VARIABLE
) {
256 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%s", sym
->name
);
257 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "+0x%llx",
258 ip
- map
->unmap_ip(map
, sym
->start
));
260 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%.*s",
265 size_t len
= BITS_PER_LONG
/ 4;
266 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%-#.*llx",
273 static int hist_entry__sym_snprintf(struct hist_entry
*he
, char *bf
,
274 size_t size
, unsigned int width
)
276 return _hist_entry__sym_snprintf(he
->ms
.map
, he
->ms
.sym
, he
->ip
,
277 he
->level
, bf
, size
, width
);
280 struct sort_entry sort_sym
= {
281 .se_header
= "Symbol",
282 .se_cmp
= sort__sym_cmp
,
283 .se_sort
= sort__sym_sort
,
284 .se_snprintf
= hist_entry__sym_snprintf
,
285 .se_width_idx
= HISTC_SYMBOL
,
290 static char *hist_entry__get_srcline(struct hist_entry
*he
)
292 struct map
*map
= he
->ms
.map
;
295 return SRCLINE_UNKNOWN
;
297 return get_srcline(map
->dso
, map__rip_2objdump(map
, he
->ip
),
302 sort__srcline_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
305 left
->srcline
= hist_entry__get_srcline(left
);
307 right
->srcline
= hist_entry__get_srcline(right
);
309 return strcmp(right
->srcline
, left
->srcline
);
312 static int hist_entry__srcline_snprintf(struct hist_entry
*he
, char *bf
,
313 size_t size
, unsigned int width
)
316 he
->srcline
= hist_entry__get_srcline(he
);
318 return repsep_snprintf(bf
, size
, "%-.*s", width
, he
->srcline
);
321 struct sort_entry sort_srcline
= {
322 .se_header
= "Source:Line",
323 .se_cmp
= sort__srcline_cmp
,
324 .se_snprintf
= hist_entry__srcline_snprintf
,
325 .se_width_idx
= HISTC_SRCLINE
,
330 static char no_srcfile
[1];
332 static char *hist_entry__get_srcfile(struct hist_entry
*e
)
335 struct map
*map
= e
->ms
.map
;
340 sf
= __get_srcline(map
->dso
, map__rip_2objdump(map
, e
->ip
),
341 e
->ms
.sym
, false, true);
342 if (!strcmp(sf
, SRCLINE_UNKNOWN
))
354 sort__srcfile_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
357 left
->srcfile
= hist_entry__get_srcfile(left
);
359 right
->srcfile
= hist_entry__get_srcfile(right
);
361 return strcmp(right
->srcfile
, left
->srcfile
);
364 static int hist_entry__srcfile_snprintf(struct hist_entry
*he
, char *bf
,
365 size_t size
, unsigned int width
)
368 he
->srcfile
= hist_entry__get_srcfile(he
);
370 return repsep_snprintf(bf
, size
, "%-.*s", width
, he
->srcfile
);
373 struct sort_entry sort_srcfile
= {
374 .se_header
= "Source File",
375 .se_cmp
= sort__srcfile_cmp
,
376 .se_snprintf
= hist_entry__srcfile_snprintf
,
377 .se_width_idx
= HISTC_SRCFILE
,
383 sort__parent_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
385 struct symbol
*sym_l
= left
->parent
;
386 struct symbol
*sym_r
= right
->parent
;
388 if (!sym_l
|| !sym_r
)
389 return cmp_null(sym_l
, sym_r
);
391 return strcmp(sym_r
->name
, sym_l
->name
);
394 static int hist_entry__parent_snprintf(struct hist_entry
*he
, char *bf
,
395 size_t size
, unsigned int width
)
397 return repsep_snprintf(bf
, size
, "%-*.*s", width
, width
,
398 he
->parent
? he
->parent
->name
: "[other]");
401 struct sort_entry sort_parent
= {
402 .se_header
= "Parent symbol",
403 .se_cmp
= sort__parent_cmp
,
404 .se_snprintf
= hist_entry__parent_snprintf
,
405 .se_width_idx
= HISTC_PARENT
,
411 sort__cpu_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
413 return right
->cpu
- left
->cpu
;
416 static int hist_entry__cpu_snprintf(struct hist_entry
*he
, char *bf
,
417 size_t size
, unsigned int width
)
419 return repsep_snprintf(bf
, size
, "%*.*d", width
, width
, he
->cpu
);
422 struct sort_entry sort_cpu
= {
424 .se_cmp
= sort__cpu_cmp
,
425 .se_snprintf
= hist_entry__cpu_snprintf
,
426 .se_width_idx
= HISTC_CPU
,
432 sort__socket_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
434 return right
->socket
- left
->socket
;
437 static int hist_entry__socket_snprintf(struct hist_entry
*he
, char *bf
,
438 size_t size
, unsigned int width
)
440 return repsep_snprintf(bf
, size
, "%*.*d", width
, width
-3, he
->socket
);
443 struct sort_entry sort_socket
= {
444 .se_header
= "Socket",
445 .se_cmp
= sort__socket_cmp
,
446 .se_snprintf
= hist_entry__socket_snprintf
,
447 .se_width_idx
= HISTC_SOCKET
,
452 static char *get_trace_output(struct hist_entry
*he
)
454 struct trace_seq seq
;
455 struct perf_evsel
*evsel
;
456 struct pevent_record rec
= {
457 .data
= he
->raw_data
,
458 .size
= he
->raw_size
,
461 evsel
= hists_to_evsel(he
->hists
);
463 trace_seq_init(&seq
);
464 if (symbol_conf
.raw_trace
) {
465 pevent_print_fields(&seq
, he
->raw_data
, he
->raw_size
,
468 pevent_event_info(&seq
, evsel
->tp_format
, &rec
);
474 sort__trace_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
476 struct perf_evsel
*evsel
;
478 evsel
= hists_to_evsel(left
->hists
);
479 if (evsel
->attr
.type
!= PERF_TYPE_TRACEPOINT
)
482 if (left
->trace_output
== NULL
)
483 left
->trace_output
= get_trace_output(left
);
484 if (right
->trace_output
== NULL
)
485 right
->trace_output
= get_trace_output(right
);
487 return strcmp(right
->trace_output
, left
->trace_output
);
490 static int hist_entry__trace_snprintf(struct hist_entry
*he
, char *bf
,
491 size_t size
, unsigned int width
)
493 struct perf_evsel
*evsel
;
495 evsel
= hists_to_evsel(he
->hists
);
496 if (evsel
->attr
.type
!= PERF_TYPE_TRACEPOINT
)
497 return scnprintf(bf
, size
, "%-.*s", width
, "N/A");
499 if (he
->trace_output
== NULL
)
500 he
->trace_output
= get_trace_output(he
);
501 return repsep_snprintf(bf
, size
, "%-.*s", width
, he
->trace_output
);
504 struct sort_entry sort_trace
= {
505 .se_header
= "Trace output",
506 .se_cmp
= sort__trace_cmp
,
507 .se_snprintf
= hist_entry__trace_snprintf
,
508 .se_width_idx
= HISTC_TRACE
,
511 /* sort keys for branch stacks */
514 sort__dso_from_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
516 if (!left
->branch_info
|| !right
->branch_info
)
517 return cmp_null(left
->branch_info
, right
->branch_info
);
519 return _sort__dso_cmp(left
->branch_info
->from
.map
,
520 right
->branch_info
->from
.map
);
523 static int hist_entry__dso_from_snprintf(struct hist_entry
*he
, char *bf
,
524 size_t size
, unsigned int width
)
527 return _hist_entry__dso_snprintf(he
->branch_info
->from
.map
,
530 return repsep_snprintf(bf
, size
, "%-*.*s", width
, width
, "N/A");
534 sort__dso_to_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
536 if (!left
->branch_info
|| !right
->branch_info
)
537 return cmp_null(left
->branch_info
, right
->branch_info
);
539 return _sort__dso_cmp(left
->branch_info
->to
.map
,
540 right
->branch_info
->to
.map
);
543 static int hist_entry__dso_to_snprintf(struct hist_entry
*he
, char *bf
,
544 size_t size
, unsigned int width
)
547 return _hist_entry__dso_snprintf(he
->branch_info
->to
.map
,
550 return repsep_snprintf(bf
, size
, "%-*.*s", width
, width
, "N/A");
554 sort__sym_from_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
556 struct addr_map_symbol
*from_l
= &left
->branch_info
->from
;
557 struct addr_map_symbol
*from_r
= &right
->branch_info
->from
;
559 if (!left
->branch_info
|| !right
->branch_info
)
560 return cmp_null(left
->branch_info
, right
->branch_info
);
562 from_l
= &left
->branch_info
->from
;
563 from_r
= &right
->branch_info
->from
;
565 if (!from_l
->sym
&& !from_r
->sym
)
566 return _sort__addr_cmp(from_l
->addr
, from_r
->addr
);
568 return _sort__sym_cmp(from_l
->sym
, from_r
->sym
);
572 sort__sym_to_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
574 struct addr_map_symbol
*to_l
, *to_r
;
576 if (!left
->branch_info
|| !right
->branch_info
)
577 return cmp_null(left
->branch_info
, right
->branch_info
);
579 to_l
= &left
->branch_info
->to
;
580 to_r
= &right
->branch_info
->to
;
582 if (!to_l
->sym
&& !to_r
->sym
)
583 return _sort__addr_cmp(to_l
->addr
, to_r
->addr
);
585 return _sort__sym_cmp(to_l
->sym
, to_r
->sym
);
588 static int hist_entry__sym_from_snprintf(struct hist_entry
*he
, char *bf
,
589 size_t size
, unsigned int width
)
591 if (he
->branch_info
) {
592 struct addr_map_symbol
*from
= &he
->branch_info
->from
;
594 return _hist_entry__sym_snprintf(from
->map
, from
->sym
, from
->addr
,
595 he
->level
, bf
, size
, width
);
598 return repsep_snprintf(bf
, size
, "%-*.*s", width
, width
, "N/A");
601 static int hist_entry__sym_to_snprintf(struct hist_entry
*he
, char *bf
,
602 size_t size
, unsigned int width
)
604 if (he
->branch_info
) {
605 struct addr_map_symbol
*to
= &he
->branch_info
->to
;
607 return _hist_entry__sym_snprintf(to
->map
, to
->sym
, to
->addr
,
608 he
->level
, bf
, size
, width
);
611 return repsep_snprintf(bf
, size
, "%-*.*s", width
, width
, "N/A");
614 struct sort_entry sort_dso_from
= {
615 .se_header
= "Source Shared Object",
616 .se_cmp
= sort__dso_from_cmp
,
617 .se_snprintf
= hist_entry__dso_from_snprintf
,
618 .se_width_idx
= HISTC_DSO_FROM
,
621 struct sort_entry sort_dso_to
= {
622 .se_header
= "Target Shared Object",
623 .se_cmp
= sort__dso_to_cmp
,
624 .se_snprintf
= hist_entry__dso_to_snprintf
,
625 .se_width_idx
= HISTC_DSO_TO
,
628 struct sort_entry sort_sym_from
= {
629 .se_header
= "Source Symbol",
630 .se_cmp
= sort__sym_from_cmp
,
631 .se_snprintf
= hist_entry__sym_from_snprintf
,
632 .se_width_idx
= HISTC_SYMBOL_FROM
,
635 struct sort_entry sort_sym_to
= {
636 .se_header
= "Target Symbol",
637 .se_cmp
= sort__sym_to_cmp
,
638 .se_snprintf
= hist_entry__sym_to_snprintf
,
639 .se_width_idx
= HISTC_SYMBOL_TO
,
643 sort__mispredict_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
647 if (!left
->branch_info
|| !right
->branch_info
)
648 return cmp_null(left
->branch_info
, right
->branch_info
);
650 mp
= left
->branch_info
->flags
.mispred
!= right
->branch_info
->flags
.mispred
;
651 p
= left
->branch_info
->flags
.predicted
!= right
->branch_info
->flags
.predicted
;
655 static int hist_entry__mispredict_snprintf(struct hist_entry
*he
, char *bf
,
656 size_t size
, unsigned int width
){
657 static const char *out
= "N/A";
659 if (he
->branch_info
) {
660 if (he
->branch_info
->flags
.predicted
)
662 else if (he
->branch_info
->flags
.mispred
)
666 return repsep_snprintf(bf
, size
, "%-*.*s", width
, width
, out
);
670 sort__cycles_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
672 return left
->branch_info
->flags
.cycles
-
673 right
->branch_info
->flags
.cycles
;
676 static int hist_entry__cycles_snprintf(struct hist_entry
*he
, char *bf
,
677 size_t size
, unsigned int width
)
679 if (he
->branch_info
->flags
.cycles
== 0)
680 return repsep_snprintf(bf
, size
, "%-*s", width
, "-");
681 return repsep_snprintf(bf
, size
, "%-*hd", width
,
682 he
->branch_info
->flags
.cycles
);
685 struct sort_entry sort_cycles
= {
686 .se_header
= "Basic Block Cycles",
687 .se_cmp
= sort__cycles_cmp
,
688 .se_snprintf
= hist_entry__cycles_snprintf
,
689 .se_width_idx
= HISTC_CYCLES
,
692 /* --sort daddr_sym */
694 sort__daddr_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
696 uint64_t l
= 0, r
= 0;
699 l
= left
->mem_info
->daddr
.addr
;
701 r
= right
->mem_info
->daddr
.addr
;
703 return (int64_t)(r
- l
);
706 static int hist_entry__daddr_snprintf(struct hist_entry
*he
, char *bf
,
707 size_t size
, unsigned int width
)
710 struct map
*map
= NULL
;
711 struct symbol
*sym
= NULL
;
714 addr
= he
->mem_info
->daddr
.addr
;
715 map
= he
->mem_info
->daddr
.map
;
716 sym
= he
->mem_info
->daddr
.sym
;
718 return _hist_entry__sym_snprintf(map
, sym
, addr
, he
->level
, bf
, size
,
723 sort__iaddr_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
725 uint64_t l
= 0, r
= 0;
728 l
= left
->mem_info
->iaddr
.addr
;
730 r
= right
->mem_info
->iaddr
.addr
;
732 return (int64_t)(r
- l
);
735 static int hist_entry__iaddr_snprintf(struct hist_entry
*he
, char *bf
,
736 size_t size
, unsigned int width
)
739 struct map
*map
= NULL
;
740 struct symbol
*sym
= NULL
;
743 addr
= he
->mem_info
->iaddr
.addr
;
744 map
= he
->mem_info
->iaddr
.map
;
745 sym
= he
->mem_info
->iaddr
.sym
;
747 return _hist_entry__sym_snprintf(map
, sym
, addr
, he
->level
, bf
, size
,
752 sort__dso_daddr_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
754 struct map
*map_l
= NULL
;
755 struct map
*map_r
= NULL
;
758 map_l
= left
->mem_info
->daddr
.map
;
760 map_r
= right
->mem_info
->daddr
.map
;
762 return _sort__dso_cmp(map_l
, map_r
);
765 static int hist_entry__dso_daddr_snprintf(struct hist_entry
*he
, char *bf
,
766 size_t size
, unsigned int width
)
768 struct map
*map
= NULL
;
771 map
= he
->mem_info
->daddr
.map
;
773 return _hist_entry__dso_snprintf(map
, bf
, size
, width
);
777 sort__locked_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
779 union perf_mem_data_src data_src_l
;
780 union perf_mem_data_src data_src_r
;
783 data_src_l
= left
->mem_info
->data_src
;
785 data_src_l
.mem_lock
= PERF_MEM_LOCK_NA
;
788 data_src_r
= right
->mem_info
->data_src
;
790 data_src_r
.mem_lock
= PERF_MEM_LOCK_NA
;
792 return (int64_t)(data_src_r
.mem_lock
- data_src_l
.mem_lock
);
795 static int hist_entry__locked_snprintf(struct hist_entry
*he
, char *bf
,
796 size_t size
, unsigned int width
)
799 u64 mask
= PERF_MEM_LOCK_NA
;
802 mask
= he
->mem_info
->data_src
.mem_lock
;
804 if (mask
& PERF_MEM_LOCK_NA
)
806 else if (mask
& PERF_MEM_LOCK_LOCKED
)
811 return repsep_snprintf(bf
, size
, "%.*s", width
, out
);
815 sort__tlb_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
817 union perf_mem_data_src data_src_l
;
818 union perf_mem_data_src data_src_r
;
821 data_src_l
= left
->mem_info
->data_src
;
823 data_src_l
.mem_dtlb
= PERF_MEM_TLB_NA
;
826 data_src_r
= right
->mem_info
->data_src
;
828 data_src_r
.mem_dtlb
= PERF_MEM_TLB_NA
;
830 return (int64_t)(data_src_r
.mem_dtlb
- data_src_l
.mem_dtlb
);
833 static int hist_entry__tlb_snprintf(struct hist_entry
*he
, char *bf
,
834 size_t size
, unsigned int width
)
838 perf_mem__tlb_scnprintf(out
, sizeof(out
), he
->mem_info
);
839 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
843 sort__lvl_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
845 union perf_mem_data_src data_src_l
;
846 union perf_mem_data_src data_src_r
;
849 data_src_l
= left
->mem_info
->data_src
;
851 data_src_l
.mem_lvl
= PERF_MEM_LVL_NA
;
854 data_src_r
= right
->mem_info
->data_src
;
856 data_src_r
.mem_lvl
= PERF_MEM_LVL_NA
;
858 return (int64_t)(data_src_r
.mem_lvl
- data_src_l
.mem_lvl
);
861 static int hist_entry__lvl_snprintf(struct hist_entry
*he
, char *bf
,
862 size_t size
, unsigned int width
)
866 perf_mem__lvl_scnprintf(out
, sizeof(out
), he
->mem_info
);
867 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
871 sort__snoop_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
873 union perf_mem_data_src data_src_l
;
874 union perf_mem_data_src data_src_r
;
877 data_src_l
= left
->mem_info
->data_src
;
879 data_src_l
.mem_snoop
= PERF_MEM_SNOOP_NA
;
882 data_src_r
= right
->mem_info
->data_src
;
884 data_src_r
.mem_snoop
= PERF_MEM_SNOOP_NA
;
886 return (int64_t)(data_src_r
.mem_snoop
- data_src_l
.mem_snoop
);
889 static const char * const snoop_access
[] = {
897 static int hist_entry__snoop_snprintf(struct hist_entry
*he
, char *bf
,
898 size_t size
, unsigned int width
)
901 size_t sz
= sizeof(out
) - 1; /* -1 for null termination */
903 u64 m
= PERF_MEM_SNOOP_NA
;
908 m
= he
->mem_info
->data_src
.mem_snoop
;
910 for (i
= 0; m
&& i
< ARRAY_SIZE(snoop_access
); i
++, m
>>= 1) {
917 strncat(out
, snoop_access
[i
], sz
- l
);
918 l
+= strlen(snoop_access
[i
]);
924 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
928 sort__dcacheline_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
931 struct map
*l_map
, *r_map
;
933 if (!left
->mem_info
) return -1;
934 if (!right
->mem_info
) return 1;
936 /* group event types together */
937 if (left
->cpumode
> right
->cpumode
) return -1;
938 if (left
->cpumode
< right
->cpumode
) return 1;
940 l_map
= left
->mem_info
->daddr
.map
;
941 r_map
= right
->mem_info
->daddr
.map
;
943 /* if both are NULL, jump to sort on al_addr instead */
944 if (!l_map
&& !r_map
)
947 if (!l_map
) return -1;
948 if (!r_map
) return 1;
950 if (l_map
->maj
> r_map
->maj
) return -1;
951 if (l_map
->maj
< r_map
->maj
) return 1;
953 if (l_map
->min
> r_map
->min
) return -1;
954 if (l_map
->min
< r_map
->min
) return 1;
956 if (l_map
->ino
> r_map
->ino
) return -1;
957 if (l_map
->ino
< r_map
->ino
) return 1;
959 if (l_map
->ino_generation
> r_map
->ino_generation
) return -1;
960 if (l_map
->ino_generation
< r_map
->ino_generation
) return 1;
963 * Addresses with no major/minor numbers are assumed to be
964 * anonymous in userspace. Sort those on pid then address.
966 * The kernel and non-zero major/minor mapped areas are
967 * assumed to be unity mapped. Sort those on address.
970 if ((left
->cpumode
!= PERF_RECORD_MISC_KERNEL
) &&
971 (!(l_map
->flags
& MAP_SHARED
)) &&
972 !l_map
->maj
&& !l_map
->min
&& !l_map
->ino
&&
973 !l_map
->ino_generation
) {
974 /* userspace anonymous */
976 if (left
->thread
->pid_
> right
->thread
->pid_
) return -1;
977 if (left
->thread
->pid_
< right
->thread
->pid_
) return 1;
981 /* al_addr does all the right addr - start + offset calculations */
982 l
= cl_address(left
->mem_info
->daddr
.al_addr
);
983 r
= cl_address(right
->mem_info
->daddr
.al_addr
);
985 if (l
> r
) return -1;
991 static int hist_entry__dcacheline_snprintf(struct hist_entry
*he
, char *bf
,
992 size_t size
, unsigned int width
)
996 struct map
*map
= NULL
;
997 struct symbol
*sym
= NULL
;
998 char level
= he
->level
;
1001 addr
= cl_address(he
->mem_info
->daddr
.al_addr
);
1002 map
= he
->mem_info
->daddr
.map
;
1003 sym
= he
->mem_info
->daddr
.sym
;
1005 /* print [s] for shared data mmaps */
1006 if ((he
->cpumode
!= PERF_RECORD_MISC_KERNEL
) &&
1007 map
&& (map
->type
== MAP__VARIABLE
) &&
1008 (map
->flags
& MAP_SHARED
) &&
1009 (map
->maj
|| map
->min
|| map
->ino
||
1010 map
->ino_generation
))
1015 return _hist_entry__sym_snprintf(map
, sym
, addr
, level
, bf
, size
,
1019 struct sort_entry sort_mispredict
= {
1020 .se_header
= "Branch Mispredicted",
1021 .se_cmp
= sort__mispredict_cmp
,
1022 .se_snprintf
= hist_entry__mispredict_snprintf
,
1023 .se_width_idx
= HISTC_MISPREDICT
,
1026 static u64
he_weight(struct hist_entry
*he
)
1028 return he
->stat
.nr_events
? he
->stat
.weight
/ he
->stat
.nr_events
: 0;
1032 sort__local_weight_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
1034 return he_weight(left
) - he_weight(right
);
1037 static int hist_entry__local_weight_snprintf(struct hist_entry
*he
, char *bf
,
1038 size_t size
, unsigned int width
)
1040 return repsep_snprintf(bf
, size
, "%-*llu", width
, he_weight(he
));
1043 struct sort_entry sort_local_weight
= {
1044 .se_header
= "Local Weight",
1045 .se_cmp
= sort__local_weight_cmp
,
1046 .se_snprintf
= hist_entry__local_weight_snprintf
,
1047 .se_width_idx
= HISTC_LOCAL_WEIGHT
,
1051 sort__global_weight_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
1053 return left
->stat
.weight
- right
->stat
.weight
;
1056 static int hist_entry__global_weight_snprintf(struct hist_entry
*he
, char *bf
,
1057 size_t size
, unsigned int width
)
1059 return repsep_snprintf(bf
, size
, "%-*llu", width
, he
->stat
.weight
);
1062 struct sort_entry sort_global_weight
= {
1063 .se_header
= "Weight",
1064 .se_cmp
= sort__global_weight_cmp
,
1065 .se_snprintf
= hist_entry__global_weight_snprintf
,
1066 .se_width_idx
= HISTC_GLOBAL_WEIGHT
,
1069 struct sort_entry sort_mem_daddr_sym
= {
1070 .se_header
= "Data Symbol",
1071 .se_cmp
= sort__daddr_cmp
,
1072 .se_snprintf
= hist_entry__daddr_snprintf
,
1073 .se_width_idx
= HISTC_MEM_DADDR_SYMBOL
,
1076 struct sort_entry sort_mem_iaddr_sym
= {
1077 .se_header
= "Code Symbol",
1078 .se_cmp
= sort__iaddr_cmp
,
1079 .se_snprintf
= hist_entry__iaddr_snprintf
,
1080 .se_width_idx
= HISTC_MEM_IADDR_SYMBOL
,
1083 struct sort_entry sort_mem_daddr_dso
= {
1084 .se_header
= "Data Object",
1085 .se_cmp
= sort__dso_daddr_cmp
,
1086 .se_snprintf
= hist_entry__dso_daddr_snprintf
,
1087 .se_width_idx
= HISTC_MEM_DADDR_SYMBOL
,
1090 struct sort_entry sort_mem_locked
= {
1091 .se_header
= "Locked",
1092 .se_cmp
= sort__locked_cmp
,
1093 .se_snprintf
= hist_entry__locked_snprintf
,
1094 .se_width_idx
= HISTC_MEM_LOCKED
,
1097 struct sort_entry sort_mem_tlb
= {
1098 .se_header
= "TLB access",
1099 .se_cmp
= sort__tlb_cmp
,
1100 .se_snprintf
= hist_entry__tlb_snprintf
,
1101 .se_width_idx
= HISTC_MEM_TLB
,
1104 struct sort_entry sort_mem_lvl
= {
1105 .se_header
= "Memory access",
1106 .se_cmp
= sort__lvl_cmp
,
1107 .se_snprintf
= hist_entry__lvl_snprintf
,
1108 .se_width_idx
= HISTC_MEM_LVL
,
1111 struct sort_entry sort_mem_snoop
= {
1112 .se_header
= "Snoop",
1113 .se_cmp
= sort__snoop_cmp
,
1114 .se_snprintf
= hist_entry__snoop_snprintf
,
1115 .se_width_idx
= HISTC_MEM_SNOOP
,
1118 struct sort_entry sort_mem_dcacheline
= {
1119 .se_header
= "Data Cacheline",
1120 .se_cmp
= sort__dcacheline_cmp
,
1121 .se_snprintf
= hist_entry__dcacheline_snprintf
,
1122 .se_width_idx
= HISTC_MEM_DCACHELINE
,
1126 sort__abort_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
1128 if (!left
->branch_info
|| !right
->branch_info
)
1129 return cmp_null(left
->branch_info
, right
->branch_info
);
1131 return left
->branch_info
->flags
.abort
!=
1132 right
->branch_info
->flags
.abort
;
1135 static int hist_entry__abort_snprintf(struct hist_entry
*he
, char *bf
,
1136 size_t size
, unsigned int width
)
1138 static const char *out
= "N/A";
1140 if (he
->branch_info
) {
1141 if (he
->branch_info
->flags
.abort
)
1147 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
1150 struct sort_entry sort_abort
= {
1151 .se_header
= "Transaction abort",
1152 .se_cmp
= sort__abort_cmp
,
1153 .se_snprintf
= hist_entry__abort_snprintf
,
1154 .se_width_idx
= HISTC_ABORT
,
1158 sort__in_tx_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
1160 if (!left
->branch_info
|| !right
->branch_info
)
1161 return cmp_null(left
->branch_info
, right
->branch_info
);
1163 return left
->branch_info
->flags
.in_tx
!=
1164 right
->branch_info
->flags
.in_tx
;
1167 static int hist_entry__in_tx_snprintf(struct hist_entry
*he
, char *bf
,
1168 size_t size
, unsigned int width
)
1170 static const char *out
= "N/A";
1172 if (he
->branch_info
) {
1173 if (he
->branch_info
->flags
.in_tx
)
1179 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
1182 struct sort_entry sort_in_tx
= {
1183 .se_header
= "Branch in transaction",
1184 .se_cmp
= sort__in_tx_cmp
,
1185 .se_snprintf
= hist_entry__in_tx_snprintf
,
1186 .se_width_idx
= HISTC_IN_TX
,
1190 sort__transaction_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
1192 return left
->transaction
- right
->transaction
;
1195 static inline char *add_str(char *p
, const char *str
)
1198 return p
+ strlen(str
);
1201 static struct txbit
{
1206 { PERF_TXN_ELISION
, "EL ", 0 },
1207 { PERF_TXN_TRANSACTION
, "TX ", 1 },
1208 { PERF_TXN_SYNC
, "SYNC ", 1 },
1209 { PERF_TXN_ASYNC
, "ASYNC ", 0 },
1210 { PERF_TXN_RETRY
, "RETRY ", 0 },
1211 { PERF_TXN_CONFLICT
, "CON ", 0 },
1212 { PERF_TXN_CAPACITY_WRITE
, "CAP-WRITE ", 1 },
1213 { PERF_TXN_CAPACITY_READ
, "CAP-READ ", 0 },
1217 int hist_entry__transaction_len(void)
1222 for (i
= 0; txbits
[i
].name
; i
++) {
1223 if (!txbits
[i
].skip_for_len
)
1224 len
+= strlen(txbits
[i
].name
);
1226 len
+= 4; /* :XX<space> */
1230 static int hist_entry__transaction_snprintf(struct hist_entry
*he
, char *bf
,
1231 size_t size
, unsigned int width
)
1233 u64 t
= he
->transaction
;
1239 for (i
= 0; txbits
[i
].name
; i
++)
1240 if (txbits
[i
].flag
& t
)
1241 p
= add_str(p
, txbits
[i
].name
);
1242 if (t
&& !(t
& (PERF_TXN_SYNC
|PERF_TXN_ASYNC
)))
1243 p
= add_str(p
, "NEITHER ");
1244 if (t
& PERF_TXN_ABORT_MASK
) {
1245 sprintf(p
, ":%" PRIx64
,
1246 (t
& PERF_TXN_ABORT_MASK
) >>
1247 PERF_TXN_ABORT_SHIFT
);
1251 return repsep_snprintf(bf
, size
, "%-*s", width
, buf
);
1254 struct sort_entry sort_transaction
= {
1255 .se_header
= "Transaction ",
1256 .se_cmp
= sort__transaction_cmp
,
1257 .se_snprintf
= hist_entry__transaction_snprintf
,
1258 .se_width_idx
= HISTC_TRANSACTION
,
1261 struct sort_dimension
{
1263 struct sort_entry
*entry
;
1267 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
1269 static struct sort_dimension common_sort_dimensions
[] = {
1270 DIM(SORT_PID
, "pid", sort_thread
),
1271 DIM(SORT_COMM
, "comm", sort_comm
),
1272 DIM(SORT_DSO
, "dso", sort_dso
),
1273 DIM(SORT_SYM
, "symbol", sort_sym
),
1274 DIM(SORT_PARENT
, "parent", sort_parent
),
1275 DIM(SORT_CPU
, "cpu", sort_cpu
),
1276 DIM(SORT_SOCKET
, "socket", sort_socket
),
1277 DIM(SORT_SRCLINE
, "srcline", sort_srcline
),
1278 DIM(SORT_SRCFILE
, "srcfile", sort_srcfile
),
1279 DIM(SORT_LOCAL_WEIGHT
, "local_weight", sort_local_weight
),
1280 DIM(SORT_GLOBAL_WEIGHT
, "weight", sort_global_weight
),
1281 DIM(SORT_TRANSACTION
, "transaction", sort_transaction
),
1282 DIM(SORT_TRACE
, "trace", sort_trace
),
1287 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
1289 static struct sort_dimension bstack_sort_dimensions
[] = {
1290 DIM(SORT_DSO_FROM
, "dso_from", sort_dso_from
),
1291 DIM(SORT_DSO_TO
, "dso_to", sort_dso_to
),
1292 DIM(SORT_SYM_FROM
, "symbol_from", sort_sym_from
),
1293 DIM(SORT_SYM_TO
, "symbol_to", sort_sym_to
),
1294 DIM(SORT_MISPREDICT
, "mispredict", sort_mispredict
),
1295 DIM(SORT_IN_TX
, "in_tx", sort_in_tx
),
1296 DIM(SORT_ABORT
, "abort", sort_abort
),
1297 DIM(SORT_CYCLES
, "cycles", sort_cycles
),
1302 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
1304 static struct sort_dimension memory_sort_dimensions
[] = {
1305 DIM(SORT_MEM_DADDR_SYMBOL
, "symbol_daddr", sort_mem_daddr_sym
),
1306 DIM(SORT_MEM_IADDR_SYMBOL
, "symbol_iaddr", sort_mem_iaddr_sym
),
1307 DIM(SORT_MEM_DADDR_DSO
, "dso_daddr", sort_mem_daddr_dso
),
1308 DIM(SORT_MEM_LOCKED
, "locked", sort_mem_locked
),
1309 DIM(SORT_MEM_TLB
, "tlb", sort_mem_tlb
),
1310 DIM(SORT_MEM_LVL
, "mem", sort_mem_lvl
),
1311 DIM(SORT_MEM_SNOOP
, "snoop", sort_mem_snoop
),
1312 DIM(SORT_MEM_DCACHELINE
, "dcacheline", sort_mem_dcacheline
),
1317 struct hpp_dimension
{
1319 struct perf_hpp_fmt
*fmt
;
1323 #define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], }
1325 static struct hpp_dimension hpp_sort_dimensions
[] = {
1326 DIM(PERF_HPP__OVERHEAD
, "overhead"),
1327 DIM(PERF_HPP__OVERHEAD_SYS
, "overhead_sys"),
1328 DIM(PERF_HPP__OVERHEAD_US
, "overhead_us"),
1329 DIM(PERF_HPP__OVERHEAD_GUEST_SYS
, "overhead_guest_sys"),
1330 DIM(PERF_HPP__OVERHEAD_GUEST_US
, "overhead_guest_us"),
1331 DIM(PERF_HPP__OVERHEAD_ACC
, "overhead_children"),
1332 DIM(PERF_HPP__SAMPLES
, "sample"),
1333 DIM(PERF_HPP__PERIOD
, "period"),
1338 struct hpp_sort_entry
{
1339 struct perf_hpp_fmt hpp
;
1340 struct sort_entry
*se
;
1343 void perf_hpp__reset_sort_width(struct perf_hpp_fmt
*fmt
, struct hists
*hists
)
1345 struct hpp_sort_entry
*hse
;
1347 if (!perf_hpp__is_sort_entry(fmt
))
1350 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
1351 hists__new_col_len(hists
, hse
->se
->se_width_idx
, strlen(fmt
->name
));
1354 static int __sort__hpp_header(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1355 struct perf_evsel
*evsel
)
1357 struct hpp_sort_entry
*hse
;
1358 size_t len
= fmt
->user_len
;
1360 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
1363 len
= hists__col_len(evsel__hists(evsel
), hse
->se
->se_width_idx
);
1365 return scnprintf(hpp
->buf
, hpp
->size
, "%-*.*s", len
, len
, fmt
->name
);
1368 static int __sort__hpp_width(struct perf_hpp_fmt
*fmt
,
1369 struct perf_hpp
*hpp __maybe_unused
,
1370 struct perf_evsel
*evsel
)
1372 struct hpp_sort_entry
*hse
;
1373 size_t len
= fmt
->user_len
;
1375 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
1378 len
= hists__col_len(evsel__hists(evsel
), hse
->se
->se_width_idx
);
1383 static int __sort__hpp_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1384 struct hist_entry
*he
)
1386 struct hpp_sort_entry
*hse
;
1387 size_t len
= fmt
->user_len
;
1389 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
1392 len
= hists__col_len(he
->hists
, hse
->se
->se_width_idx
);
1394 return hse
->se
->se_snprintf(he
, hpp
->buf
, hpp
->size
, len
);
1397 static int64_t __sort__hpp_cmp(struct perf_hpp_fmt
*fmt
,
1398 struct hist_entry
*a
, struct hist_entry
*b
)
1400 struct hpp_sort_entry
*hse
;
1402 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
1403 return hse
->se
->se_cmp(a
, b
);
1406 static int64_t __sort__hpp_collapse(struct perf_hpp_fmt
*fmt
,
1407 struct hist_entry
*a
, struct hist_entry
*b
)
1409 struct hpp_sort_entry
*hse
;
1410 int64_t (*collapse_fn
)(struct hist_entry
*, struct hist_entry
*);
1412 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
1413 collapse_fn
= hse
->se
->se_collapse
?: hse
->se
->se_cmp
;
1414 return collapse_fn(a
, b
);
1417 static int64_t __sort__hpp_sort(struct perf_hpp_fmt
*fmt
,
1418 struct hist_entry
*a
, struct hist_entry
*b
)
1420 struct hpp_sort_entry
*hse
;
1421 int64_t (*sort_fn
)(struct hist_entry
*, struct hist_entry
*);
1423 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
1424 sort_fn
= hse
->se
->se_sort
?: hse
->se
->se_cmp
;
1425 return sort_fn(a
, b
);
1428 bool perf_hpp__is_sort_entry(struct perf_hpp_fmt
*format
)
1430 return format
->header
== __sort__hpp_header
;
1433 static bool __sort__hpp_equal(struct perf_hpp_fmt
*a
, struct perf_hpp_fmt
*b
)
1435 struct hpp_sort_entry
*hse_a
;
1436 struct hpp_sort_entry
*hse_b
;
1438 if (!perf_hpp__is_sort_entry(a
) || !perf_hpp__is_sort_entry(b
))
1441 hse_a
= container_of(a
, struct hpp_sort_entry
, hpp
);
1442 hse_b
= container_of(b
, struct hpp_sort_entry
, hpp
);
1444 return hse_a
->se
== hse_b
->se
;
1447 static void hse_free(struct perf_hpp_fmt
*fmt
)
1449 struct hpp_sort_entry
*hse
;
1451 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
1455 static struct hpp_sort_entry
*
1456 __sort_dimension__alloc_hpp(struct sort_dimension
*sd
)
1458 struct hpp_sort_entry
*hse
;
1460 hse
= malloc(sizeof(*hse
));
1462 pr_err("Memory allocation failed\n");
1466 hse
->se
= sd
->entry
;
1467 hse
->hpp
.name
= sd
->entry
->se_header
;
1468 hse
->hpp
.header
= __sort__hpp_header
;
1469 hse
->hpp
.width
= __sort__hpp_width
;
1470 hse
->hpp
.entry
= __sort__hpp_entry
;
1471 hse
->hpp
.color
= NULL
;
1473 hse
->hpp
.cmp
= __sort__hpp_cmp
;
1474 hse
->hpp
.collapse
= __sort__hpp_collapse
;
1475 hse
->hpp
.sort
= __sort__hpp_sort
;
1476 hse
->hpp
.equal
= __sort__hpp_equal
;
1477 hse
->hpp
.free
= hse_free
;
1479 INIT_LIST_HEAD(&hse
->hpp
.list
);
1480 INIT_LIST_HEAD(&hse
->hpp
.sort_list
);
1481 hse
->hpp
.elide
= false;
1483 hse
->hpp
.user_len
= 0;
1488 static void hpp_free(struct perf_hpp_fmt
*fmt
)
1493 static struct perf_hpp_fmt
*__hpp_dimension__alloc_hpp(struct hpp_dimension
*hd
)
1495 struct perf_hpp_fmt
*fmt
;
1497 fmt
= memdup(hd
->fmt
, sizeof(*fmt
));
1499 INIT_LIST_HEAD(&fmt
->list
);
1500 INIT_LIST_HEAD(&fmt
->sort_list
);
1501 fmt
->free
= hpp_free
;
1507 static int __sort_dimension__add_hpp_sort(struct sort_dimension
*sd
)
1509 struct hpp_sort_entry
*hse
= __sort_dimension__alloc_hpp(sd
);
1514 perf_hpp__register_sort_field(&hse
->hpp
);
1518 static int __sort_dimension__add_hpp_output(struct perf_hpp_list
*list
,
1519 struct sort_dimension
*sd
)
1521 struct hpp_sort_entry
*hse
= __sort_dimension__alloc_hpp(sd
);
1526 perf_hpp_list__column_register(list
, &hse
->hpp
);
1530 struct hpp_dynamic_entry
{
1531 struct perf_hpp_fmt hpp
;
1532 struct perf_evsel
*evsel
;
1533 struct format_field
*field
;
1534 unsigned dynamic_len
;
1538 static int hde_width(struct hpp_dynamic_entry
*hde
)
1540 if (!hde
->hpp
.len
) {
1541 int len
= hde
->dynamic_len
;
1542 int namelen
= strlen(hde
->field
->name
);
1543 int fieldlen
= hde
->field
->size
;
1548 if (!(hde
->field
->flags
& FIELD_IS_STRING
)) {
1549 /* length for print hex numbers */
1550 fieldlen
= hde
->field
->size
* 2 + 2;
1557 return hde
->hpp
.len
;
1560 static void update_dynamic_len(struct hpp_dynamic_entry
*hde
,
1561 struct hist_entry
*he
)
1564 struct format_field
*field
= hde
->field
;
1571 /* parse pretty print result and update max length */
1572 if (!he
->trace_output
)
1573 he
->trace_output
= get_trace_output(he
);
1575 namelen
= strlen(field
->name
);
1576 str
= he
->trace_output
;
1579 pos
= strchr(str
, ' ');
1582 pos
= str
+ strlen(str
);
1585 if (!strncmp(str
, field
->name
, namelen
)) {
1591 if (len
> hde
->dynamic_len
)
1592 hde
->dynamic_len
= len
;
1603 static int __sort__hde_header(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1604 struct perf_evsel
*evsel __maybe_unused
)
1606 struct hpp_dynamic_entry
*hde
;
1607 size_t len
= fmt
->user_len
;
1609 hde
= container_of(fmt
, struct hpp_dynamic_entry
, hpp
);
1612 len
= hde_width(hde
);
1614 return scnprintf(hpp
->buf
, hpp
->size
, "%*.*s", len
, len
, hde
->field
->name
);
1617 static int __sort__hde_width(struct perf_hpp_fmt
*fmt
,
1618 struct perf_hpp
*hpp __maybe_unused
,
1619 struct perf_evsel
*evsel __maybe_unused
)
1621 struct hpp_dynamic_entry
*hde
;
1622 size_t len
= fmt
->user_len
;
1624 hde
= container_of(fmt
, struct hpp_dynamic_entry
, hpp
);
1627 len
= hde_width(hde
);
1632 bool perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt
*fmt
, struct hists
*hists
)
1634 struct hpp_dynamic_entry
*hde
;
1636 hde
= container_of(fmt
, struct hpp_dynamic_entry
, hpp
);
1638 return hists_to_evsel(hists
) == hde
->evsel
;
1641 static int __sort__hde_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1642 struct hist_entry
*he
)
1644 struct hpp_dynamic_entry
*hde
;
1645 size_t len
= fmt
->user_len
;
1647 struct format_field
*field
;
1652 hde
= container_of(fmt
, struct hpp_dynamic_entry
, hpp
);
1655 len
= hde_width(hde
);
1661 namelen
= strlen(field
->name
);
1662 str
= he
->trace_output
;
1665 pos
= strchr(str
, ' ');
1668 pos
= str
+ strlen(str
);
1671 if (!strncmp(str
, field
->name
, namelen
)) {
1673 str
= strndup(str
, pos
- str
);
1676 return scnprintf(hpp
->buf
, hpp
->size
,
1677 "%*.*s", len
, len
, "ERROR");
1688 struct trace_seq seq
;
1690 trace_seq_init(&seq
);
1691 pevent_print_field(&seq
, he
->raw_data
, hde
->field
);
1695 ret
= scnprintf(hpp
->buf
, hpp
->size
, "%*.*s", len
, len
, str
);
1700 static int64_t __sort__hde_cmp(struct perf_hpp_fmt
*fmt
,
1701 struct hist_entry
*a
, struct hist_entry
*b
)
1703 struct hpp_dynamic_entry
*hde
;
1704 struct format_field
*field
;
1705 unsigned offset
, size
;
1707 hde
= container_of(fmt
, struct hpp_dynamic_entry
, hpp
);
1710 if (field
->flags
& FIELD_IS_DYNAMIC
) {
1711 unsigned long long dyn
;
1713 pevent_read_number_field(field
, a
->raw_data
, &dyn
);
1714 offset
= dyn
& 0xffff;
1715 size
= (dyn
>> 16) & 0xffff;
1717 /* record max width for output */
1718 if (size
> hde
->dynamic_len
)
1719 hde
->dynamic_len
= size
;
1721 offset
= field
->offset
;
1724 update_dynamic_len(hde
, a
);
1725 update_dynamic_len(hde
, b
);
1728 return memcmp(a
->raw_data
+ offset
, b
->raw_data
+ offset
, size
);
1731 bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt
*fmt
)
1733 return fmt
->cmp
== __sort__hde_cmp
;
1736 static bool __sort__hde_equal(struct perf_hpp_fmt
*a
, struct perf_hpp_fmt
*b
)
1738 struct hpp_dynamic_entry
*hde_a
;
1739 struct hpp_dynamic_entry
*hde_b
;
1741 if (!perf_hpp__is_dynamic_entry(a
) || !perf_hpp__is_dynamic_entry(b
))
1744 hde_a
= container_of(a
, struct hpp_dynamic_entry
, hpp
);
1745 hde_b
= container_of(b
, struct hpp_dynamic_entry
, hpp
);
1747 return hde_a
->field
== hde_b
->field
;
1750 static void hde_free(struct perf_hpp_fmt
*fmt
)
1752 struct hpp_dynamic_entry
*hde
;
1754 hde
= container_of(fmt
, struct hpp_dynamic_entry
, hpp
);
1758 static struct hpp_dynamic_entry
*
1759 __alloc_dynamic_entry(struct perf_evsel
*evsel
, struct format_field
*field
)
1761 struct hpp_dynamic_entry
*hde
;
1763 hde
= malloc(sizeof(*hde
));
1765 pr_debug("Memory allocation failed\n");
1771 hde
->dynamic_len
= 0;
1773 hde
->hpp
.name
= field
->name
;
1774 hde
->hpp
.header
= __sort__hde_header
;
1775 hde
->hpp
.width
= __sort__hde_width
;
1776 hde
->hpp
.entry
= __sort__hde_entry
;
1777 hde
->hpp
.color
= NULL
;
1779 hde
->hpp
.cmp
= __sort__hde_cmp
;
1780 hde
->hpp
.collapse
= __sort__hde_cmp
;
1781 hde
->hpp
.sort
= __sort__hde_cmp
;
1782 hde
->hpp
.equal
= __sort__hde_equal
;
1783 hde
->hpp
.free
= hde_free
;
1785 INIT_LIST_HEAD(&hde
->hpp
.list
);
1786 INIT_LIST_HEAD(&hde
->hpp
.sort_list
);
1787 hde
->hpp
.elide
= false;
1789 hde
->hpp
.user_len
= 0;
1794 static int parse_field_name(char *str
, char **event
, char **field
, char **opt
)
1796 char *event_name
, *field_name
, *opt_name
;
1799 field_name
= strchr(str
, '.');
1802 *field_name
++ = '\0';
1808 opt_name
= strchr(field_name
, '/');
1812 *event
= event_name
;
1813 *field
= field_name
;
1819 /* find match evsel using a given event name. The event name can be:
1820 * 1. '%' + event index (e.g. '%1' for first event)
1821 * 2. full event name (e.g. sched:sched_switch)
1822 * 3. partial event name (should not contain ':')
1824 static struct perf_evsel
*find_evsel(struct perf_evlist
*evlist
, char *event_name
)
1826 struct perf_evsel
*evsel
= NULL
;
1827 struct perf_evsel
*pos
;
1831 if (event_name
[0] == '%') {
1832 int nr
= strtol(event_name
+1, NULL
, 0);
1834 if (nr
> evlist
->nr_entries
)
1837 evsel
= perf_evlist__first(evlist
);
1839 evsel
= perf_evsel__next(evsel
);
1844 full_name
= !!strchr(event_name
, ':');
1845 evlist__for_each(evlist
, pos
) {
1847 if (full_name
&& !strcmp(pos
->name
, event_name
))
1850 if (!full_name
&& strstr(pos
->name
, event_name
)) {
1852 pr_debug("'%s' event is ambiguous: it can be %s or %s\n",
1853 event_name
, evsel
->name
, pos
->name
);
1863 static int __dynamic_dimension__add(struct perf_evsel
*evsel
,
1864 struct format_field
*field
,
1867 struct hpp_dynamic_entry
*hde
;
1869 hde
= __alloc_dynamic_entry(evsel
, field
);
1873 hde
->raw_trace
= raw_trace
;
1875 perf_hpp__register_sort_field(&hde
->hpp
);
1879 static int add_evsel_fields(struct perf_evsel
*evsel
, bool raw_trace
)
1882 struct format_field
*field
;
1884 field
= evsel
->tp_format
->format
.fields
;
1886 ret
= __dynamic_dimension__add(evsel
, field
, raw_trace
);
1890 field
= field
->next
;
1895 static int add_all_dynamic_fields(struct perf_evlist
*evlist
, bool raw_trace
)
1898 struct perf_evsel
*evsel
;
1900 evlist__for_each(evlist
, evsel
) {
1901 if (evsel
->attr
.type
!= PERF_TYPE_TRACEPOINT
)
1904 ret
= add_evsel_fields(evsel
, raw_trace
);
1911 static int add_all_matching_fields(struct perf_evlist
*evlist
,
1912 char *field_name
, bool raw_trace
)
1915 struct perf_evsel
*evsel
;
1916 struct format_field
*field
;
1918 evlist__for_each(evlist
, evsel
) {
1919 if (evsel
->attr
.type
!= PERF_TYPE_TRACEPOINT
)
1922 field
= pevent_find_any_field(evsel
->tp_format
, field_name
);
1926 ret
= __dynamic_dimension__add(evsel
, field
, raw_trace
);
1933 static int add_dynamic_entry(struct perf_evlist
*evlist
, const char *tok
)
1935 char *str
, *event_name
, *field_name
, *opt_name
;
1936 struct perf_evsel
*evsel
;
1937 struct format_field
*field
;
1938 bool raw_trace
= symbol_conf
.raw_trace
;
1948 if (parse_field_name(str
, &event_name
, &field_name
, &opt_name
) < 0) {
1954 if (strcmp(opt_name
, "raw")) {
1955 pr_debug("unsupported field option %s\n", opt_name
);
1962 if (!strcmp(field_name
, "trace_fields")) {
1963 ret
= add_all_dynamic_fields(evlist
, raw_trace
);
1967 if (event_name
== NULL
) {
1968 ret
= add_all_matching_fields(evlist
, field_name
, raw_trace
);
1972 evsel
= find_evsel(evlist
, event_name
);
1973 if (evsel
== NULL
) {
1974 pr_debug("Cannot find event: %s\n", event_name
);
1979 if (evsel
->attr
.type
!= PERF_TYPE_TRACEPOINT
) {
1980 pr_debug("%s is not a tracepoint event\n", event_name
);
1985 if (!strcmp(field_name
, "*")) {
1986 ret
= add_evsel_fields(evsel
, raw_trace
);
1988 field
= pevent_find_any_field(evsel
->tp_format
, field_name
);
1989 if (field
== NULL
) {
1990 pr_debug("Cannot find event field for %s.%s\n",
1991 event_name
, field_name
);
1995 ret
= __dynamic_dimension__add(evsel
, field
, raw_trace
);
2003 static int __sort_dimension__add(struct sort_dimension
*sd
)
2008 if (__sort_dimension__add_hpp_sort(sd
) < 0)
2011 if (sd
->entry
->se_collapse
)
2012 sort__need_collapse
= 1;
2019 static int __hpp_dimension__add(struct hpp_dimension
*hd
)
2021 struct perf_hpp_fmt
*fmt
;
2026 fmt
= __hpp_dimension__alloc_hpp(hd
);
2031 perf_hpp__register_sort_field(fmt
);
2035 static int __sort_dimension__add_output(struct perf_hpp_list
*list
,
2036 struct sort_dimension
*sd
)
2041 if (__sort_dimension__add_hpp_output(list
, sd
) < 0)
2048 static int __hpp_dimension__add_output(struct perf_hpp_list
*list
,
2049 struct hpp_dimension
*hd
)
2051 struct perf_hpp_fmt
*fmt
;
2056 fmt
= __hpp_dimension__alloc_hpp(hd
);
2061 perf_hpp_list__column_register(list
, fmt
);
2065 int hpp_dimension__add_output(unsigned col
)
2067 BUG_ON(col
>= PERF_HPP__MAX_INDEX
);
2068 return __hpp_dimension__add_output(&perf_hpp_list
, &hpp_sort_dimensions
[col
]);
2071 static int sort_dimension__add(const char *tok
,
2072 struct perf_evlist
*evlist __maybe_unused
)
2076 for (i
= 0; i
< ARRAY_SIZE(common_sort_dimensions
); i
++) {
2077 struct sort_dimension
*sd
= &common_sort_dimensions
[i
];
2079 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
2082 if (sd
->entry
== &sort_parent
) {
2083 int ret
= regcomp(&parent_regex
, parent_pattern
, REG_EXTENDED
);
2087 regerror(ret
, &parent_regex
, err
, sizeof(err
));
2088 pr_err("Invalid regex: %s\n%s", parent_pattern
, err
);
2091 sort__has_parent
= 1;
2092 } else if (sd
->entry
== &sort_sym
) {
2095 * perf diff displays the performance difference amongst
2096 * two or more perf.data files. Those files could come
2097 * from different binaries. So we should not compare
2098 * their ips, but the name of symbol.
2100 if (sort__mode
== SORT_MODE__DIFF
)
2101 sd
->entry
->se_collapse
= sort__sym_sort
;
2103 } else if (sd
->entry
== &sort_dso
) {
2105 } else if (sd
->entry
== &sort_socket
) {
2106 sort__has_socket
= 1;
2107 } else if (sd
->entry
== &sort_thread
) {
2108 sort__has_thread
= 1;
2111 return __sort_dimension__add(sd
);
2114 for (i
= 0; i
< ARRAY_SIZE(hpp_sort_dimensions
); i
++) {
2115 struct hpp_dimension
*hd
= &hpp_sort_dimensions
[i
];
2117 if (strncasecmp(tok
, hd
->name
, strlen(tok
)))
2120 return __hpp_dimension__add(hd
);
2123 for (i
= 0; i
< ARRAY_SIZE(bstack_sort_dimensions
); i
++) {
2124 struct sort_dimension
*sd
= &bstack_sort_dimensions
[i
];
2126 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
2129 if (sort__mode
!= SORT_MODE__BRANCH
)
2132 if (sd
->entry
== &sort_sym_from
|| sd
->entry
== &sort_sym_to
)
2135 __sort_dimension__add(sd
);
2139 for (i
= 0; i
< ARRAY_SIZE(memory_sort_dimensions
); i
++) {
2140 struct sort_dimension
*sd
= &memory_sort_dimensions
[i
];
2142 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
2145 if (sort__mode
!= SORT_MODE__MEMORY
)
2148 if (sd
->entry
== &sort_mem_daddr_sym
)
2151 __sort_dimension__add(sd
);
2155 if (!add_dynamic_entry(evlist
, tok
))
2161 static int setup_sort_list(char *str
, struct perf_evlist
*evlist
)
2166 for (tok
= strtok_r(str
, ", ", &tmp
);
2167 tok
; tok
= strtok_r(NULL
, ", ", &tmp
)) {
2168 ret
= sort_dimension__add(tok
, evlist
);
2169 if (ret
== -EINVAL
) {
2170 error("Invalid --sort key: `%s'", tok
);
2172 } else if (ret
== -ESRCH
) {
2173 error("Unknown --sort key: `%s'", tok
);
2181 static const char *get_default_sort_order(struct perf_evlist
*evlist
)
2183 const char *default_sort_orders
[] = {
2185 default_branch_sort_order
,
2186 default_mem_sort_order
,
2187 default_top_sort_order
,
2188 default_diff_sort_order
,
2189 default_tracepoint_sort_order
,
2191 bool use_trace
= true;
2192 struct perf_evsel
*evsel
;
2194 BUG_ON(sort__mode
>= ARRAY_SIZE(default_sort_orders
));
2199 evlist__for_each(evlist
, evsel
) {
2200 if (evsel
->attr
.type
!= PERF_TYPE_TRACEPOINT
) {
2207 sort__mode
= SORT_MODE__TRACEPOINT
;
2208 if (symbol_conf
.raw_trace
)
2209 return "trace_fields";
2212 return default_sort_orders
[sort__mode
];
2215 static int setup_sort_order(struct perf_evlist
*evlist
)
2217 char *new_sort_order
;
2220 * Append '+'-prefixed sort order to the default sort
2223 if (!sort_order
|| is_strict_order(sort_order
))
2226 if (sort_order
[1] == '\0') {
2227 error("Invalid --sort key: `+'");
2232 * We allocate new sort_order string, but we never free it,
2233 * because it's checked over the rest of the code.
2235 if (asprintf(&new_sort_order
, "%s,%s",
2236 get_default_sort_order(evlist
), sort_order
+ 1) < 0) {
2237 error("Not enough memory to set up --sort");
2241 sort_order
= new_sort_order
;
2246 * Adds 'pre,' prefix into 'str' is 'pre' is
2247 * not already part of 'str'.
2249 static char *prefix_if_not_in(const char *pre
, char *str
)
2253 if (!str
|| strstr(str
, pre
))
2256 if (asprintf(&n
, "%s,%s", pre
, str
) < 0)
2263 static char *setup_overhead(char *keys
)
2265 keys
= prefix_if_not_in("overhead", keys
);
2267 if (symbol_conf
.cumulate_callchain
)
2268 keys
= prefix_if_not_in("overhead_children", keys
);
2273 static int __setup_sorting(struct perf_evlist
*evlist
)
2276 const char *sort_keys
;
2279 ret
= setup_sort_order(evlist
);
2283 sort_keys
= sort_order
;
2284 if (sort_keys
== NULL
) {
2285 if (is_strict_order(field_order
)) {
2287 * If user specified field order but no sort order,
2288 * we'll honor it and not add default sort orders.
2293 sort_keys
= get_default_sort_order(evlist
);
2296 str
= strdup(sort_keys
);
2298 error("Not enough memory to setup sort keys");
2303 * Prepend overhead fields for backward compatibility.
2305 if (!is_strict_order(field_order
)) {
2306 str
= setup_overhead(str
);
2308 error("Not enough memory to setup overhead keys");
2313 ret
= setup_sort_list(str
, evlist
);
2319 void perf_hpp__set_elide(int idx
, bool elide
)
2321 struct perf_hpp_fmt
*fmt
;
2322 struct hpp_sort_entry
*hse
;
2324 perf_hpp_list__for_each_format(&perf_hpp_list
, fmt
) {
2325 if (!perf_hpp__is_sort_entry(fmt
))
2328 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
2329 if (hse
->se
->se_width_idx
== idx
) {
2336 static bool __get_elide(struct strlist
*list
, const char *list_name
, FILE *fp
)
2338 if (list
&& strlist__nr_entries(list
) == 1) {
2340 fprintf(fp
, "# %s: %s\n", list_name
,
2341 strlist__entry(list
, 0)->s
);
2347 static bool get_elide(int idx
, FILE *output
)
2351 return __get_elide(symbol_conf
.sym_list
, "symbol", output
);
2353 return __get_elide(symbol_conf
.dso_list
, "dso", output
);
2355 return __get_elide(symbol_conf
.comm_list
, "comm", output
);
2360 if (sort__mode
!= SORT_MODE__BRANCH
)
2364 case HISTC_SYMBOL_FROM
:
2365 return __get_elide(symbol_conf
.sym_from_list
, "sym_from", output
);
2366 case HISTC_SYMBOL_TO
:
2367 return __get_elide(symbol_conf
.sym_to_list
, "sym_to", output
);
2368 case HISTC_DSO_FROM
:
2369 return __get_elide(symbol_conf
.dso_from_list
, "dso_from", output
);
2371 return __get_elide(symbol_conf
.dso_to_list
, "dso_to", output
);
2379 void sort__setup_elide(FILE *output
)
2381 struct perf_hpp_fmt
*fmt
;
2382 struct hpp_sort_entry
*hse
;
2384 perf_hpp_list__for_each_format(&perf_hpp_list
, fmt
) {
2385 if (!perf_hpp__is_sort_entry(fmt
))
2388 hse
= container_of(fmt
, struct hpp_sort_entry
, hpp
);
2389 fmt
->elide
= get_elide(hse
->se
->se_width_idx
, output
);
2393 * It makes no sense to elide all of sort entries.
2394 * Just revert them to show up again.
2396 perf_hpp_list__for_each_format(&perf_hpp_list
, fmt
) {
2397 if (!perf_hpp__is_sort_entry(fmt
))
2404 perf_hpp_list__for_each_format(&perf_hpp_list
, fmt
) {
2405 if (!perf_hpp__is_sort_entry(fmt
))
2412 static int output_field_add(struct perf_hpp_list
*list
, char *tok
)
2416 for (i
= 0; i
< ARRAY_SIZE(common_sort_dimensions
); i
++) {
2417 struct sort_dimension
*sd
= &common_sort_dimensions
[i
];
2419 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
2422 return __sort_dimension__add_output(list
, sd
);
2425 for (i
= 0; i
< ARRAY_SIZE(hpp_sort_dimensions
); i
++) {
2426 struct hpp_dimension
*hd
= &hpp_sort_dimensions
[i
];
2428 if (strncasecmp(tok
, hd
->name
, strlen(tok
)))
2431 return __hpp_dimension__add_output(list
, hd
);
2434 for (i
= 0; i
< ARRAY_SIZE(bstack_sort_dimensions
); i
++) {
2435 struct sort_dimension
*sd
= &bstack_sort_dimensions
[i
];
2437 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
2440 return __sort_dimension__add_output(list
, sd
);
2443 for (i
= 0; i
< ARRAY_SIZE(memory_sort_dimensions
); i
++) {
2444 struct sort_dimension
*sd
= &memory_sort_dimensions
[i
];
2446 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
2449 return __sort_dimension__add_output(list
, sd
);
2455 static int setup_output_list(struct perf_hpp_list
*list
, char *str
)
2460 for (tok
= strtok_r(str
, ", ", &tmp
);
2461 tok
; tok
= strtok_r(NULL
, ", ", &tmp
)) {
2462 ret
= output_field_add(list
, tok
);
2463 if (ret
== -EINVAL
) {
2464 error("Invalid --fields key: `%s'", tok
);
2466 } else if (ret
== -ESRCH
) {
2467 error("Unknown --fields key: `%s'", tok
);
2475 static void reset_dimensions(void)
2479 for (i
= 0; i
< ARRAY_SIZE(common_sort_dimensions
); i
++)
2480 common_sort_dimensions
[i
].taken
= 0;
2482 for (i
= 0; i
< ARRAY_SIZE(hpp_sort_dimensions
); i
++)
2483 hpp_sort_dimensions
[i
].taken
= 0;
2485 for (i
= 0; i
< ARRAY_SIZE(bstack_sort_dimensions
); i
++)
2486 bstack_sort_dimensions
[i
].taken
= 0;
2488 for (i
= 0; i
< ARRAY_SIZE(memory_sort_dimensions
); i
++)
2489 memory_sort_dimensions
[i
].taken
= 0;
2492 bool is_strict_order(const char *order
)
2494 return order
&& (*order
!= '+');
2497 static int __setup_output_field(void)
2502 if (field_order
== NULL
)
2505 strp
= str
= strdup(field_order
);
2507 error("Not enough memory to setup output fields");
2511 if (!is_strict_order(field_order
))
2514 if (!strlen(strp
)) {
2515 error("Invalid --fields key: `+'");
2519 ret
= setup_output_list(&perf_hpp_list
, strp
);
2526 int setup_sorting(struct perf_evlist
*evlist
)
2530 err
= __setup_sorting(evlist
);
2534 if (parent_pattern
!= default_parent_pattern
) {
2535 err
= sort_dimension__add("parent", evlist
);
2543 * perf diff doesn't use default hpp output fields.
2545 if (sort__mode
!= SORT_MODE__DIFF
)
2548 err
= __setup_output_field();
2552 /* copy sort keys to output fields */
2553 perf_hpp__setup_output_field(&perf_hpp_list
);
2554 /* and then copy output fields to sort keys */
2555 perf_hpp__append_sort_keys(&perf_hpp_list
);
2560 void reset_output_field(void)
2562 sort__need_collapse
= 0;
2563 sort__has_parent
= 0;
2571 perf_hpp__reset_output_field(&perf_hpp_list
);