/tools/perf/util/sort.c
C | 3193 lines | 2462 code | 627 blank | 104 comment | 474 complexity | e2cb9929f5409fe7a2af22113602ebb8 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
Large files files are truncated, but you can click here to view the full file
- // SPDX-License-Identifier: GPL-2.0
- #include <errno.h>
- #include <inttypes.h>
- #include <regex.h>
- #include <stdlib.h>
- #include <linux/mman.h>
- #include <linux/time64.h>
- #include "debug.h"
- #include "dso.h"
- #include "sort.h"
- #include "hist.h"
- #include "cacheline.h"
- #include "comm.h"
- #include "map.h"
- #include "maps.h"
- #include "symbol.h"
- #include "map_symbol.h"
- #include "branch.h"
- #include "thread.h"
- #include "evsel.h"
- #include "evlist.h"
- #include "srcline.h"
- #include "strlist.h"
- #include "strbuf.h"
- #include <traceevent/event-parse.h>
- #include "mem-events.h"
- #include "annotate.h"
- #include "time-utils.h"
- #include "cgroup.h"
- #include "machine.h"
- #include <linux/kernel.h>
- #include <linux/string.h>
- regex_t parent_regex;
- const char default_parent_pattern[] = "^sys_|^do_page_fault";
- const char *parent_pattern = default_parent_pattern;
- const char *default_sort_order = "comm,dso,symbol";
- const char default_branch_sort_order[] = "comm,dso_from,symbol_from,symbol_to,cycles";
- const char default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked";
- const char default_top_sort_order[] = "dso,symbol";
- const char default_diff_sort_order[] = "dso,symbol";
- const char default_tracepoint_sort_order[] = "trace";
- const char *sort_order;
- const char *field_order;
- regex_t ignore_callees_regex;
- int have_ignore_callees = 0;
- enum sort_mode sort__mode = SORT_MODE__NORMAL;
- /*
- * Replaces all occurrences of a char used with the:
- *
- * -t, --field-separator
- *
- * option, that uses a special separator character and don't pad with spaces,
- * replacing all occurrences of this separator in symbol names (and other
- * output) with a '.' character, that thus it's the only non valid separator.
- */
- static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
- {
- int n;
- va_list ap;
- va_start(ap, fmt);
- n = vsnprintf(bf, size, fmt, ap);
- if (symbol_conf.field_sep && n > 0) {
- char *sep = bf;
- while (1) {
- sep = strchr(sep, *symbol_conf.field_sep);
- if (sep == NULL)
- break;
- *sep = '.';
- }
- }
- va_end(ap);
- if (n >= (int)size)
- return size - 1;
- return n;
- }
- static int64_t cmp_null(const void *l, const void *r)
- {
- if (!l && !r)
- return 0;
- else if (!l)
- return -1;
- else
- return 1;
- }
- /* --sort pid */
- static int64_t
- sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return right->thread->tid - left->thread->tid;
- }
- static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- const char *comm = thread__comm_str(he->thread);
- width = max(7U, width) - 8;
- return repsep_snprintf(bf, size, "%7d:%-*.*s", he->thread->tid,
- width, width, comm ?: "");
- }
- static int hist_entry__thread_filter(struct hist_entry *he, int type, const void *arg)
- {
- const struct thread *th = arg;
- if (type != HIST_FILTER__THREAD)
- return -1;
- return th && he->thread != th;
- }
- struct sort_entry sort_thread = {
- .se_header = " Pid:Command",
- .se_cmp = sort__thread_cmp,
- .se_snprintf = hist_entry__thread_snprintf,
- .se_filter = hist_entry__thread_filter,
- .se_width_idx = HISTC_THREAD,
- };
- /* --sort comm */
- /*
- * We can't use pointer comparison in functions below,
- * because it gives different results based on pointer
- * values, which could break some sorting assumptions.
- */
- static int64_t
- sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return strcmp(comm__str(right->comm), comm__str(left->comm));
- }
- static int64_t
- sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
- {
- return strcmp(comm__str(right->comm), comm__str(left->comm));
- }
- static int64_t
- sort__comm_sort(struct hist_entry *left, struct hist_entry *right)
- {
- return strcmp(comm__str(right->comm), comm__str(left->comm));
- }
- static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm));
- }
- struct sort_entry sort_comm = {
- .se_header = "Command",
- .se_cmp = sort__comm_cmp,
- .se_collapse = sort__comm_collapse,
- .se_sort = sort__comm_sort,
- .se_snprintf = hist_entry__comm_snprintf,
- .se_filter = hist_entry__thread_filter,
- .se_width_idx = HISTC_COMM,
- };
- /* --sort dso */
- static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
- {
- struct dso *dso_l = map_l ? map_l->dso : NULL;
- struct dso *dso_r = map_r ? map_r->dso : NULL;
- const char *dso_name_l, *dso_name_r;
- if (!dso_l || !dso_r)
- return cmp_null(dso_r, dso_l);
- if (verbose > 0) {
- dso_name_l = dso_l->long_name;
- dso_name_r = dso_r->long_name;
- } else {
- dso_name_l = dso_l->short_name;
- dso_name_r = dso_r->short_name;
- }
- return strcmp(dso_name_l, dso_name_r);
- }
- static int64_t
- sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return _sort__dso_cmp(right->ms.map, left->ms.map);
- }
- static int _hist_entry__dso_snprintf(struct map *map, char *bf,
- size_t size, unsigned int width)
- {
- if (map && map->dso) {
- const char *dso_name = verbose > 0 ? map->dso->long_name :
- map->dso->short_name;
- return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name);
- }
- return repsep_snprintf(bf, size, "%-*.*s", width, width, "[unknown]");
- }
- static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return _hist_entry__dso_snprintf(he->ms.map, bf, size, width);
- }
- static int hist_entry__dso_filter(struct hist_entry *he, int type, const void *arg)
- {
- const struct dso *dso = arg;
- if (type != HIST_FILTER__DSO)
- return -1;
- return dso && (!he->ms.map || he->ms.map->dso != dso);
- }
- struct sort_entry sort_dso = {
- .se_header = "Shared Object",
- .se_cmp = sort__dso_cmp,
- .se_snprintf = hist_entry__dso_snprintf,
- .se_filter = hist_entry__dso_filter,
- .se_width_idx = HISTC_DSO,
- };
- /* --sort symbol */
- static int64_t _sort__addr_cmp(u64 left_ip, u64 right_ip)
- {
- return (int64_t)(right_ip - left_ip);
- }
- static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
- {
- if (!sym_l || !sym_r)
- return cmp_null(sym_l, sym_r);
- if (sym_l == sym_r)
- return 0;
- if (sym_l->inlined || sym_r->inlined) {
- int ret = strcmp(sym_l->name, sym_r->name);
- if (ret)
- return ret;
- if ((sym_l->start <= sym_r->end) && (sym_l->end >= sym_r->start))
- return 0;
- }
- if (sym_l->start != sym_r->start)
- return (int64_t)(sym_r->start - sym_l->start);
- return (int64_t)(sym_r->end - sym_l->end);
- }
- static int64_t
- sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- int64_t ret;
- if (!left->ms.sym && !right->ms.sym)
- return _sort__addr_cmp(left->ip, right->ip);
- /*
- * comparing symbol address alone is not enough since it's a
- * relative address within a dso.
- */
- if (!hists__has(left->hists, dso) || hists__has(right->hists, dso)) {
- ret = sort__dso_cmp(left, right);
- if (ret != 0)
- return ret;
- }
- return _sort__sym_cmp(left->ms.sym, right->ms.sym);
- }
- static int64_t
- sort__sym_sort(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->ms.sym || !right->ms.sym)
- return cmp_null(left->ms.sym, right->ms.sym);
- return strcmp(right->ms.sym->name, left->ms.sym->name);
- }
- static int _hist_entry__sym_snprintf(struct map_symbol *ms,
- u64 ip, char level, char *bf, size_t size,
- unsigned int width)
- {
- struct symbol *sym = ms->sym;
- struct map *map = ms->map;
- size_t ret = 0;
- if (verbose > 0) {
- char o = map ? dso__symtab_origin(map->dso) : '!';
- ret += repsep_snprintf(bf, size, "%-#*llx %c ",
- BITS_PER_LONG / 4 + 2, ip, o);
- }
- ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
- if (sym && map) {
- if (sym->type == STT_OBJECT) {
- ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
- ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
- ip - map->unmap_ip(map, sym->start));
- } else {
- ret += repsep_snprintf(bf + ret, size - ret, "%.*s",
- width - ret,
- sym->name);
- if (sym->inlined)
- ret += repsep_snprintf(bf + ret, size - ret,
- " (inlined)");
- }
- } else {
- size_t len = BITS_PER_LONG / 4;
- ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
- len, ip);
- }
- return ret;
- }
- int hist_entry__sym_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width)
- {
- return _hist_entry__sym_snprintf(&he->ms, he->ip,
- he->level, bf, size, width);
- }
- static int hist_entry__sym_filter(struct hist_entry *he, int type, const void *arg)
- {
- const char *sym = arg;
- if (type != HIST_FILTER__SYMBOL)
- return -1;
- return sym && (!he->ms.sym || !strstr(he->ms.sym->name, sym));
- }
- struct sort_entry sort_sym = {
- .se_header = "Symbol",
- .se_cmp = sort__sym_cmp,
- .se_sort = sort__sym_sort,
- .se_snprintf = hist_entry__sym_snprintf,
- .se_filter = hist_entry__sym_filter,
- .se_width_idx = HISTC_SYMBOL,
- };
- /* --sort srcline */
- char *hist_entry__srcline(struct hist_entry *he)
- {
- return map__srcline(he->ms.map, he->ip, he->ms.sym);
- }
- static int64_t
- sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->srcline)
- left->srcline = hist_entry__srcline(left);
- if (!right->srcline)
- right->srcline = hist_entry__srcline(right);
- return strcmp(right->srcline, left->srcline);
- }
- static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- if (!he->srcline)
- he->srcline = hist_entry__srcline(he);
- return repsep_snprintf(bf, size, "%-.*s", width, he->srcline);
- }
- struct sort_entry sort_srcline = {
- .se_header = "Source:Line",
- .se_cmp = sort__srcline_cmp,
- .se_snprintf = hist_entry__srcline_snprintf,
- .se_width_idx = HISTC_SRCLINE,
- };
- /* --sort srcline_from */
- static char *addr_map_symbol__srcline(struct addr_map_symbol *ams)
- {
- return map__srcline(ams->ms.map, ams->al_addr, ams->ms.sym);
- }
- static int64_t
- sort__srcline_from_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->branch_info->srcline_from)
- left->branch_info->srcline_from = addr_map_symbol__srcline(&left->branch_info->from);
- if (!right->branch_info->srcline_from)
- right->branch_info->srcline_from = addr_map_symbol__srcline(&right->branch_info->from);
- return strcmp(right->branch_info->srcline_from, left->branch_info->srcline_from);
- }
- static int hist_entry__srcline_from_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return repsep_snprintf(bf, size, "%-*.*s", width, width, he->branch_info->srcline_from);
- }
- struct sort_entry sort_srcline_from = {
- .se_header = "From Source:Line",
- .se_cmp = sort__srcline_from_cmp,
- .se_snprintf = hist_entry__srcline_from_snprintf,
- .se_width_idx = HISTC_SRCLINE_FROM,
- };
- /* --sort srcline_to */
- static int64_t
- sort__srcline_to_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->branch_info->srcline_to)
- left->branch_info->srcline_to = addr_map_symbol__srcline(&left->branch_info->to);
- if (!right->branch_info->srcline_to)
- right->branch_info->srcline_to = addr_map_symbol__srcline(&right->branch_info->to);
- return strcmp(right->branch_info->srcline_to, left->branch_info->srcline_to);
- }
- static int hist_entry__srcline_to_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return repsep_snprintf(bf, size, "%-*.*s", width, width, he->branch_info->srcline_to);
- }
- struct sort_entry sort_srcline_to = {
- .se_header = "To Source:Line",
- .se_cmp = sort__srcline_to_cmp,
- .se_snprintf = hist_entry__srcline_to_snprintf,
- .se_width_idx = HISTC_SRCLINE_TO,
- };
- static int hist_entry__sym_ipc_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- struct symbol *sym = he->ms.sym;
- struct annotation *notes;
- double ipc = 0.0, coverage = 0.0;
- char tmp[64];
- if (!sym)
- return repsep_snprintf(bf, size, "%-*s", width, "-");
- notes = symbol__annotation(sym);
- if (notes->hit_cycles)
- ipc = notes->hit_insn / ((double)notes->hit_cycles);
- if (notes->total_insn) {
- coverage = notes->cover_insn * 100.0 /
- ((double)notes->total_insn);
- }
- snprintf(tmp, sizeof(tmp), "%-5.2f [%5.1f%%]", ipc, coverage);
- return repsep_snprintf(bf, size, "%-*s", width, tmp);
- }
- struct sort_entry sort_sym_ipc = {
- .se_header = "IPC [IPC Coverage]",
- .se_cmp = sort__sym_cmp,
- .se_snprintf = hist_entry__sym_ipc_snprintf,
- .se_width_idx = HISTC_SYMBOL_IPC,
- };
- static int hist_entry__sym_ipc_null_snprintf(struct hist_entry *he
- __maybe_unused,
- char *bf, size_t size,
- unsigned int width)
- {
- char tmp[64];
- snprintf(tmp, sizeof(tmp), "%-5s %2s", "-", "-");
- return repsep_snprintf(bf, size, "%-*s", width, tmp);
- }
- struct sort_entry sort_sym_ipc_null = {
- .se_header = "IPC [IPC Coverage]",
- .se_cmp = sort__sym_cmp,
- .se_snprintf = hist_entry__sym_ipc_null_snprintf,
- .se_width_idx = HISTC_SYMBOL_IPC,
- };
- /* --sort srcfile */
- static char no_srcfile[1];
- static char *hist_entry__get_srcfile(struct hist_entry *e)
- {
- char *sf, *p;
- struct map *map = e->ms.map;
- if (!map)
- return no_srcfile;
- sf = __get_srcline(map->dso, map__rip_2objdump(map, e->ip),
- e->ms.sym, false, true, true, e->ip);
- if (!strcmp(sf, SRCLINE_UNKNOWN))
- return no_srcfile;
- p = strchr(sf, ':');
- if (p && *sf) {
- *p = 0;
- return sf;
- }
- free(sf);
- return no_srcfile;
- }
- static int64_t
- sort__srcfile_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->srcfile)
- left->srcfile = hist_entry__get_srcfile(left);
- if (!right->srcfile)
- right->srcfile = hist_entry__get_srcfile(right);
- return strcmp(right->srcfile, left->srcfile);
- }
- static int hist_entry__srcfile_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- if (!he->srcfile)
- he->srcfile = hist_entry__get_srcfile(he);
- return repsep_snprintf(bf, size, "%-.*s", width, he->srcfile);
- }
- struct sort_entry sort_srcfile = {
- .se_header = "Source File",
- .se_cmp = sort__srcfile_cmp,
- .se_snprintf = hist_entry__srcfile_snprintf,
- .se_width_idx = HISTC_SRCFILE,
- };
- /* --sort parent */
- static int64_t
- sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- struct symbol *sym_l = left->parent;
- struct symbol *sym_r = right->parent;
- if (!sym_l || !sym_r)
- return cmp_null(sym_l, sym_r);
- return strcmp(sym_r->name, sym_l->name);
- }
- static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return repsep_snprintf(bf, size, "%-*.*s", width, width,
- he->parent ? he->parent->name : "[other]");
- }
- struct sort_entry sort_parent = {
- .se_header = "Parent symbol",
- .se_cmp = sort__parent_cmp,
- .se_snprintf = hist_entry__parent_snprintf,
- .se_width_idx = HISTC_PARENT,
- };
- /* --sort cpu */
- static int64_t
- sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return right->cpu - left->cpu;
- }
- static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu);
- }
- struct sort_entry sort_cpu = {
- .se_header = "CPU",
- .se_cmp = sort__cpu_cmp,
- .se_snprintf = hist_entry__cpu_snprintf,
- .se_width_idx = HISTC_CPU,
- };
- /* --sort cgroup_id */
- static int64_t _sort__cgroup_dev_cmp(u64 left_dev, u64 right_dev)
- {
- return (int64_t)(right_dev - left_dev);
- }
- static int64_t _sort__cgroup_inode_cmp(u64 left_ino, u64 right_ino)
- {
- return (int64_t)(right_ino - left_ino);
- }
- static int64_t
- sort__cgroup_id_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- int64_t ret;
- ret = _sort__cgroup_dev_cmp(right->cgroup_id.dev, left->cgroup_id.dev);
- if (ret != 0)
- return ret;
- return _sort__cgroup_inode_cmp(right->cgroup_id.ino,
- left->cgroup_id.ino);
- }
- static int hist_entry__cgroup_id_snprintf(struct hist_entry *he,
- char *bf, size_t size,
- unsigned int width __maybe_unused)
- {
- return repsep_snprintf(bf, size, "%lu/0x%lx", he->cgroup_id.dev,
- he->cgroup_id.ino);
- }
- struct sort_entry sort_cgroup_id = {
- .se_header = "cgroup id (dev/inode)",
- .se_cmp = sort__cgroup_id_cmp,
- .se_snprintf = hist_entry__cgroup_id_snprintf,
- .se_width_idx = HISTC_CGROUP_ID,
- };
- /* --sort cgroup */
- static int64_t
- sort__cgroup_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return right->cgroup - left->cgroup;
- }
- static int hist_entry__cgroup_snprintf(struct hist_entry *he,
- char *bf, size_t size,
- unsigned int width __maybe_unused)
- {
- const char *cgrp_name = "N/A";
- if (he->cgroup) {
- struct cgroup *cgrp = cgroup__find(he->ms.maps->machine->env,
- he->cgroup);
- if (cgrp != NULL)
- cgrp_name = cgrp->name;
- else
- cgrp_name = "unknown";
- }
- return repsep_snprintf(bf, size, "%s", cgrp_name);
- }
- struct sort_entry sort_cgroup = {
- .se_header = "Cgroup",
- .se_cmp = sort__cgroup_cmp,
- .se_snprintf = hist_entry__cgroup_snprintf,
- .se_width_idx = HISTC_CGROUP,
- };
- /* --sort socket */
- static int64_t
- sort__socket_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return right->socket - left->socket;
- }
- static int hist_entry__socket_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return repsep_snprintf(bf, size, "%*.*d", width, width-3, he->socket);
- }
- static int hist_entry__socket_filter(struct hist_entry *he, int type, const void *arg)
- {
- int sk = *(const int *)arg;
- if (type != HIST_FILTER__SOCKET)
- return -1;
- return sk >= 0 && he->socket != sk;
- }
- struct sort_entry sort_socket = {
- .se_header = "Socket",
- .se_cmp = sort__socket_cmp,
- .se_snprintf = hist_entry__socket_snprintf,
- .se_filter = hist_entry__socket_filter,
- .se_width_idx = HISTC_SOCKET,
- };
- /* --sort time */
- static int64_t
- sort__time_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return right->time - left->time;
- }
- static int hist_entry__time_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- char he_time[32];
- if (symbol_conf.nanosecs)
- timestamp__scnprintf_nsec(he->time, he_time,
- sizeof(he_time));
- else
- timestamp__scnprintf_usec(he->time, he_time,
- sizeof(he_time));
- return repsep_snprintf(bf, size, "%-.*s", width, he_time);
- }
- struct sort_entry sort_time = {
- .se_header = "Time",
- .se_cmp = sort__time_cmp,
- .se_snprintf = hist_entry__time_snprintf,
- .se_width_idx = HISTC_TIME,
- };
- /* --sort trace */
- static char *get_trace_output(struct hist_entry *he)
- {
- struct trace_seq seq;
- struct evsel *evsel;
- struct tep_record rec = {
- .data = he->raw_data,
- .size = he->raw_size,
- };
- evsel = hists_to_evsel(he->hists);
- trace_seq_init(&seq);
- if (symbol_conf.raw_trace) {
- tep_print_fields(&seq, he->raw_data, he->raw_size,
- evsel->tp_format);
- } else {
- tep_print_event(evsel->tp_format->tep,
- &seq, &rec, "%s", TEP_PRINT_INFO);
- }
- /*
- * Trim the buffer, it starts at 4KB and we're not going to
- * add anything more to this buffer.
- */
- return realloc(seq.buffer, seq.len + 1);
- }
- static int64_t
- sort__trace_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- struct evsel *evsel;
- evsel = hists_to_evsel(left->hists);
- if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
- return 0;
- if (left->trace_output == NULL)
- left->trace_output = get_trace_output(left);
- if (right->trace_output == NULL)
- right->trace_output = get_trace_output(right);
- return strcmp(right->trace_output, left->trace_output);
- }
- static int hist_entry__trace_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- struct evsel *evsel;
- evsel = hists_to_evsel(he->hists);
- if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
- return scnprintf(bf, size, "%-.*s", width, "N/A");
- if (he->trace_output == NULL)
- he->trace_output = get_trace_output(he);
- return repsep_snprintf(bf, size, "%-.*s", width, he->trace_output);
- }
- struct sort_entry sort_trace = {
- .se_header = "Trace output",
- .se_cmp = sort__trace_cmp,
- .se_snprintf = hist_entry__trace_snprintf,
- .se_width_idx = HISTC_TRACE,
- };
- /* sort keys for branch stacks */
- static int64_t
- sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->branch_info || !right->branch_info)
- return cmp_null(left->branch_info, right->branch_info);
- return _sort__dso_cmp(left->branch_info->from.ms.map,
- right->branch_info->from.ms.map);
- }
- static int hist_entry__dso_from_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- if (he->branch_info)
- return _hist_entry__dso_snprintf(he->branch_info->from.ms.map,
- bf, size, width);
- else
- return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
- }
- static int hist_entry__dso_from_filter(struct hist_entry *he, int type,
- const void *arg)
- {
- const struct dso *dso = arg;
- if (type != HIST_FILTER__DSO)
- return -1;
- return dso && (!he->branch_info || !he->branch_info->from.ms.map ||
- he->branch_info->from.ms.map->dso != dso);
- }
- static int64_t
- sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->branch_info || !right->branch_info)
- return cmp_null(left->branch_info, right->branch_info);
- return _sort__dso_cmp(left->branch_info->to.ms.map,
- right->branch_info->to.ms.map);
- }
- static int hist_entry__dso_to_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- if (he->branch_info)
- return _hist_entry__dso_snprintf(he->branch_info->to.ms.map,
- bf, size, width);
- else
- return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
- }
- static int hist_entry__dso_to_filter(struct hist_entry *he, int type,
- const void *arg)
- {
- const struct dso *dso = arg;
- if (type != HIST_FILTER__DSO)
- return -1;
- return dso && (!he->branch_info || !he->branch_info->to.ms.map ||
- he->branch_info->to.ms.map->dso != dso);
- }
- static int64_t
- sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- struct addr_map_symbol *from_l = &left->branch_info->from;
- struct addr_map_symbol *from_r = &right->branch_info->from;
- if (!left->branch_info || !right->branch_info)
- return cmp_null(left->branch_info, right->branch_info);
- from_l = &left->branch_info->from;
- from_r = &right->branch_info->from;
- if (!from_l->ms.sym && !from_r->ms.sym)
- return _sort__addr_cmp(from_l->addr, from_r->addr);
- return _sort__sym_cmp(from_l->ms.sym, from_r->ms.sym);
- }
- static int64_t
- sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- struct addr_map_symbol *to_l, *to_r;
- if (!left->branch_info || !right->branch_info)
- return cmp_null(left->branch_info, right->branch_info);
- to_l = &left->branch_info->to;
- to_r = &right->branch_info->to;
- if (!to_l->ms.sym && !to_r->ms.sym)
- return _sort__addr_cmp(to_l->addr, to_r->addr);
- return _sort__sym_cmp(to_l->ms.sym, to_r->ms.sym);
- }
- static int hist_entry__sym_from_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- if (he->branch_info) {
- struct addr_map_symbol *from = &he->branch_info->from;
- return _hist_entry__sym_snprintf(&from->ms, from->al_addr,
- he->level, bf, size, width);
- }
- return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
- }
- static int hist_entry__sym_to_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- if (he->branch_info) {
- struct addr_map_symbol *to = &he->branch_info->to;
- return _hist_entry__sym_snprintf(&to->ms, to->al_addr,
- he->level, bf, size, width);
- }
- return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
- }
- static int hist_entry__sym_from_filter(struct hist_entry *he, int type,
- const void *arg)
- {
- const char *sym = arg;
- if (type != HIST_FILTER__SYMBOL)
- return -1;
- return sym && !(he->branch_info && he->branch_info->from.ms.sym &&
- strstr(he->branch_info->from.ms.sym->name, sym));
- }
- static int hist_entry__sym_to_filter(struct hist_entry *he, int type,
- const void *arg)
- {
- const char *sym = arg;
- if (type != HIST_FILTER__SYMBOL)
- return -1;
- return sym && !(he->branch_info && he->branch_info->to.ms.sym &&
- strstr(he->branch_info->to.ms.sym->name, sym));
- }
- struct sort_entry sort_dso_from = {
- .se_header = "Source Shared Object",
- .se_cmp = sort__dso_from_cmp,
- .se_snprintf = hist_entry__dso_from_snprintf,
- .se_filter = hist_entry__dso_from_filter,
- .se_width_idx = HISTC_DSO_FROM,
- };
- struct sort_entry sort_dso_to = {
- .se_header = "Target Shared Object",
- .se_cmp = sort__dso_to_cmp,
- .se_snprintf = hist_entry__dso_to_snprintf,
- .se_filter = hist_entry__dso_to_filter,
- .se_width_idx = HISTC_DSO_TO,
- };
- struct sort_entry sort_sym_from = {
- .se_header = "Source Symbol",
- .se_cmp = sort__sym_from_cmp,
- .se_snprintf = hist_entry__sym_from_snprintf,
- .se_filter = hist_entry__sym_from_filter,
- .se_width_idx = HISTC_SYMBOL_FROM,
- };
- struct sort_entry sort_sym_to = {
- .se_header = "Target Symbol",
- .se_cmp = sort__sym_to_cmp,
- .se_snprintf = hist_entry__sym_to_snprintf,
- .se_filter = hist_entry__sym_to_filter,
- .se_width_idx = HISTC_SYMBOL_TO,
- };
- static int64_t
- sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- unsigned char mp, p;
- if (!left->branch_info || !right->branch_info)
- return cmp_null(left->branch_info, right->branch_info);
- mp = left->branch_info->flags.mispred != right->branch_info->flags.mispred;
- p = left->branch_info->flags.predicted != right->branch_info->flags.predicted;
- return mp || p;
- }
- static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width){
- static const char *out = "N/A";
- if (he->branch_info) {
- if (he->branch_info->flags.predicted)
- out = "N";
- else if (he->branch_info->flags.mispred)
- out = "Y";
- }
- return repsep_snprintf(bf, size, "%-*.*s", width, width, out);
- }
- static int64_t
- sort__cycles_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->branch_info || !right->branch_info)
- return cmp_null(left->branch_info, right->branch_info);
- return left->branch_info->flags.cycles -
- right->branch_info->flags.cycles;
- }
- static int hist_entry__cycles_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- if (!he->branch_info)
- return scnprintf(bf, size, "%-.*s", width, "N/A");
- if (he->branch_info->flags.cycles == 0)
- return repsep_snprintf(bf, size, "%-*s", width, "-");
- return repsep_snprintf(bf, size, "%-*hd", width,
- he->branch_info->flags.cycles);
- }
- struct sort_entry sort_cycles = {
- .se_header = "Basic Block Cycles",
- .se_cmp = sort__cycles_cmp,
- .se_snprintf = hist_entry__cycles_snprintf,
- .se_width_idx = HISTC_CYCLES,
- };
- /* --sort daddr_sym */
- int64_t
- sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- uint64_t l = 0, r = 0;
- if (left->mem_info)
- l = left->mem_info->daddr.addr;
- if (right->mem_info)
- r = right->mem_info->daddr.addr;
- return (int64_t)(r - l);
- }
- static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- uint64_t addr = 0;
- struct map_symbol *ms = NULL;
- if (he->mem_info) {
- addr = he->mem_info->daddr.addr;
- ms = &he->mem_info->daddr.ms;
- }
- return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width);
- }
- int64_t
- sort__iaddr_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- uint64_t l = 0, r = 0;
- if (left->mem_info)
- l = left->mem_info->iaddr.addr;
- if (right->mem_info)
- r = right->mem_info->iaddr.addr;
- return (int64_t)(r - l);
- }
- static int hist_entry__iaddr_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- uint64_t addr = 0;
- struct map_symbol *ms = NULL;
- if (he->mem_info) {
- addr = he->mem_info->iaddr.addr;
- ms = &he->mem_info->iaddr.ms;
- }
- return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width);
- }
- static int64_t
- sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- struct map *map_l = NULL;
- struct map *map_r = NULL;
- if (left->mem_info)
- map_l = left->mem_info->daddr.ms.map;
- if (right->mem_info)
- map_r = right->mem_info->daddr.ms.map;
- return _sort__dso_cmp(map_l, map_r);
- }
- static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- struct map *map = NULL;
- if (he->mem_info)
- map = he->mem_info->daddr.ms.map;
- return _hist_entry__dso_snprintf(map, bf, size, width);
- }
- static int64_t
- sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- union perf_mem_data_src data_src_l;
- union perf_mem_data_src data_src_r;
- if (left->mem_info)
- data_src_l = left->mem_info->data_src;
- else
- data_src_l.mem_lock = PERF_MEM_LOCK_NA;
- if (right->mem_info)
- data_src_r = right->mem_info->data_src;
- else
- data_src_r.mem_lock = PERF_MEM_LOCK_NA;
- return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
- }
- static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- char out[10];
- perf_mem__lck_scnprintf(out, sizeof(out), he->mem_info);
- return repsep_snprintf(bf, size, "%.*s", width, out);
- }
- static int64_t
- sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- union perf_mem_data_src data_src_l;
- union perf_mem_data_src data_src_r;
- if (left->mem_info)
- data_src_l = left->mem_info->data_src;
- else
- data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
- if (right->mem_info)
- data_src_r = right->mem_info->data_src;
- else
- data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
- return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
- }
- static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- char out[64];
- perf_mem__tlb_scnprintf(out, sizeof(out), he->mem_info);
- return repsep_snprintf(bf, size, "%-*s", width, out);
- }
- static int64_t
- sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- union perf_mem_data_src data_src_l;
- union perf_mem_data_src data_src_r;
- if (left->mem_info)
- data_src_l = left->mem_info->data_src;
- else
- data_src_l.mem_lvl = PERF_MEM_LVL_NA;
- if (right->mem_info)
- data_src_r = right->mem_info->data_src;
- else
- data_src_r.mem_lvl = PERF_MEM_LVL_NA;
- return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
- }
- static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- char out[64];
- perf_mem__lvl_scnprintf(out, sizeof(out), he->mem_info);
- return repsep_snprintf(bf, size, "%-*s", width, out);
- }
- static int64_t
- sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- union perf_mem_data_src data_src_l;
- union perf_mem_data_src data_src_r;
- if (left->mem_info)
- data_src_l = left->mem_info->data_src;
- else
- data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
- if (right->mem_info)
- data_src_r = right->mem_info->data_src;
- else
- data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
- return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
- }
- static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- char out[64];
- perf_mem__snp_scnprintf(out, sizeof(out), he->mem_info);
- return repsep_snprintf(bf, size, "%-*s", width, out);
- }
- int64_t
- sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- u64 l, r;
- struct map *l_map, *r_map;
- int rc;
- if (!left->mem_info) return -1;
- if (!right->mem_info) return 1;
- /* group event types together */
- if (left->cpumode > right->cpumode) return -1;
- if (left->cpumode < right->cpumode) return 1;
- l_map = left->mem_info->daddr.ms.map;
- r_map = right->mem_info->daddr.ms.map;
- /* if both are NULL, jump to sort on al_addr instead */
- if (!l_map && !r_map)
- goto addr;
- if (!l_map) return -1;
- if (!r_map) return 1;
- rc = dso__cmp_id(l_map->dso, r_map->dso);
- if (rc)
- return rc;
- /*
- * Addresses with no major/minor numbers are assumed to be
- * anonymous in userspace. Sort those on pid then address.
- *
- * The kernel and non-zero major/minor mapped areas are
- * assumed to be unity mapped. Sort those on address.
- */
- if ((left->cpumode != PERF_RECORD_MISC_KERNEL) &&
- (!(l_map->flags & MAP_SHARED)) &&
- !l_map->dso->id.maj && !l_map->dso->id.min &&
- !l_map->dso->id.ino && !l_map->dso->id.ino_generation) {
- /* userspace anonymous */
- if (left->thread->pid_ > right->thread->pid_) return -1;
- if (left->thread->pid_ < right->thread->pid_) return 1;
- }
- addr:
- /* al_addr does all the right addr - start + offset calculations */
- l = cl_address(left->mem_info->daddr.al_addr);
- r = cl_address(right->mem_info->daddr.al_addr);
- if (l > r) return -1;
- if (l < r) return 1;
- return 0;
- }
- static int hist_entry__dcacheline_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- uint64_t addr = 0;
- struct map_symbol *ms = NULL;
- char level = he->level;
- if (he->mem_info) {
- struct map *map = he->mem_info->daddr.ms.map;
- addr = cl_address(he->mem_info->daddr.al_addr);
- ms = &he->mem_info->daddr.ms;
- /* print [s] for shared data mmaps */
- if ((he->cpumode != PERF_RECORD_MISC_KERNEL) &&
- map && !(map->prot & PROT_EXEC) &&
- (map->flags & MAP_SHARED) &&
- (map->dso->id.maj || map->dso->id.min ||
- map->dso->id.ino || map->dso->id.ino_generation))
- level = 's';
- else if (!map)
- level = 'X';
- }
- return _hist_entry__sym_snprintf(ms, addr, level, bf, size, width);
- }
- struct sort_entry sort_mispredict = {
- .se_header = "Branch Mispredicted",
- .se_cmp = sort__mispredict_cmp,
- .se_snprintf = hist_entry__mispredict_snprintf,
- .se_width_idx = HISTC_MISPREDICT,
- };
- static u64 he_weight(struct hist_entry *he)
- {
- return he->stat.nr_events ? he->stat.weight / he->stat.nr_events : 0;
- }
- static int64_t
- sort__local_weight_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return he_weight(left) - he_weight(right);
- }
- static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return repsep_snprintf(bf, size, "%-*llu", width, he_weight(he));
- }
- struct sort_entry sort_local_weight = {
- .se_header = "Local Weight",
- .se_cmp = sort__local_weight_cmp,
- .se_snprintf = hist_entry__local_weight_snprintf,
- .se_width_idx = HISTC_LOCAL_WEIGHT,
- };
- static int64_t
- sort__global_weight_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return left->stat.weight - right->stat.weight;
- }
- static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return repsep_snprintf(bf, size, "%-*llu", width, he->stat.weight);
- }
- struct sort_entry sort_global_weight = {
- .se_header = "Weight",
- .se_cmp = sort__global_weight_cmp,
- .se_snprintf = hist_entry__global_weight_snprintf,
- .se_width_idx = HISTC_GLOBAL_WEIGHT,
- };
- struct sort_entry sort_mem_daddr_sym = {
- .se_header = "Data Symbol",
- .se_cmp = sort__daddr_cmp,
- .se_snprintf = hist_entry__daddr_snprintf,
- .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
- };
- struct sort_entry sort_mem_iaddr_sym = {
- .se_header = "Code Symbol",
- .se_cmp = sort__iaddr_cmp,
- .se_snprintf = hist_entry__iaddr_snprintf,
- .se_width_idx = HISTC_MEM_IADDR_SYMBOL,
- };
- struct sort_entry sort_mem_daddr_dso = {
- .se_header = "Data Object",
- .se_cmp = sort__dso_daddr_cmp,
- .se_snprintf = hist_entry__dso_daddr_snprintf,
- .se_width_idx = HISTC_MEM_DADDR_DSO,
- };
- struct sort_entry sort_mem_locked = {
- .se_header = "Locked",
- .se_cmp = sort__locked_cmp,
- .se_snprintf = hist_entry__locked_snprintf,
- .se_width_idx = HISTC_MEM_LOCKED,
- };
- struct sort_entry sort_mem_tlb = {
- .se_header = "TLB access",
- .se_cmp = sort__tlb_cmp,
- .se_snprintf = hist_entry__tlb_snprintf,
- .se_width_idx = HISTC_MEM_TLB,
- };
- struct sort_entry sort_mem_lvl = {
- .se_header = "Memory access",
- .se_cmp = sort__lvl_cmp,
- .se_snprintf = hist_entry__lvl_snprintf,
- .se_width_idx = HISTC_MEM_LVL,
- };
- struct sort_entry sort_mem_snoop = {
- .se_header = "Snoop",
- .se_cmp = sort__snoop_cmp,
- .se_snprintf = hist_entry__snoop_snprintf,
- .se_width_idx = HISTC_MEM_SNOOP,
- };
- struct sort_entry sort_mem_dcacheline = {
- .se_header = "Data Cacheline",
- .se_cmp = sort__dcacheline_cmp,
- .se_snprintf = hist_entry__dcacheline_snprintf,
- .se_width_idx = HISTC_MEM_DCACHELINE,
- };
- static int64_t
- sort__phys_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- uint64_t l = 0, r = 0;
- if (left->mem_info)
- l = left->mem_info->daddr.phys_addr;
- if (right->mem_info)
- r = right->mem_info->daddr.phys_addr;
- return (int64_t)(r - l);
- }
- static int hist_entry__phys_daddr_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- uint64_t addr = 0;
- size_t ret = 0;
- size_t len = BITS_PER_LONG / 4;
- addr = he->mem_info->daddr.phys_addr;
- ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", he->level);
- ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx", len, addr);
- ret += repsep_snprintf(bf + ret, size - ret, "%-*s", width - ret, "");
- if (ret > width)
- bf[width] = '\0';
- return width;
- }
- struct sort_entry sort_mem_phys_daddr = {
- .se_header = "Data Physical Address",
- .se_cmp = sort__phys_daddr_cmp,
- .se_snprintf = hist_entry__phys_daddr_snprintf,
- .se_width_idx = HISTC_MEM_PHYS_DADDR,
- };
- static int64_t
- sort__abort_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->branch_info || !right->branch_info)
- return cmp_null(left->branch_info, right->branch_info);
- return left->branch_info->flags.abort !=
- right->branch_info->flags.abort;
- }
- static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- static const char *out = "N/A";
- if (he->branch_info) {
- if (he->branch_info->flags.abort)
- out = "A";
- else
- out = ".";
- }
- return repsep_snprintf(bf, size, "%-*s", width, out);
- }
- struct sort_entry sort_abort = {
- .se_header = "Transaction abort",
- .se_cmp = sort__abort_cmp,
- .se_snprintf = hist_entry__abort_snprintf,
- .se_width_idx = HISTC_ABORT,
- };
- static int64_t
- sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- if (!left->branch_info || !right->branch_info)
- return cmp_null(left->branch_info, right->branch_info);
- return left->branch_info->flags.in_tx !=
- right->branch_info->flags.in_tx;
- }
- static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- static const char *out = "N/A";
- if (he->branch_info) {
- if (he->branch_info->flags.in_tx)
- out = "T";
- else
- out = ".";
- }
- return repsep_snprintf(bf, size, "%-*s", width, out);
- }
- struct sort_entry sort_in_tx = {
- .se_header = "Branch in transaction",
- .se_cmp = sort__in_tx_cmp,
- .se_snprintf = hist_entry__in_tx_snprintf,
- .se_width_idx = HISTC_IN_TX,
- };
- static int64_t
- sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return left->transaction - right->transaction;
- }
- static inline char *add_str(char *p, const char *str)
- {
- strcpy(p, str);
- return p + strlen(str);
- }
- static struct txbit {
- unsigned flag;
- const char *name;
- int skip_for_len;
- } txbits[] = {
- { PERF_TXN_ELISION, "EL ", 0 },
- { PERF_TXN_TRANSACTION, "TX ", 1 },
- { PERF_TXN_SYNC, "SYNC ", 1 },
- { PERF_TXN_ASYNC, "ASYNC ", 0 },
- { PERF_TXN_RETRY, "RETRY ", 0 },
- { PERF_TXN_CONFLICT, "CON ", 0 },
- { PERF_TXN_CAPACITY_WRITE, "CAP-WRITE ", 1 },
- { PERF_TXN_CAPACITY_READ, "CAP-READ ", 0 },
- { 0, NULL, 0 }
- };
- int hist_entry__transaction_len(void)
- {
- int i;
- int len = 0;
- for (i = 0; txbits[i].name; i++) {
- if (!txbits[i].skip_for_len)
- len += strlen(txbits[i].name);
- }
- len += 4; /* :XX<space> */
- return len;
- }
- static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- u64 t = he->transaction;
- char buf[128];
- char *p = buf;
- int i;
- buf[0] = 0;
- for (i = 0; txbits[i].name; i++)
- if (txbits[i].flag & t)
- p = add_str(p, txbits[i].name);
- if (t && !(t & (PERF_TXN_SYNC|PERF_TXN_ASYNC)))
- p = add_str(p, "NEITHER ");
- if (t & PERF_TXN_ABORT_MASK) {
- sprintf(p, ":%" PRIx64,
- (t & PERF_TXN_ABORT_MASK) >>
- PERF_TXN_ABORT_SHIFT);
- p += strlen(p);
- }
- return repsep_snprintf(bf, size, "%-*s", width, buf);
- }
- struct sort_entry sort_transaction = {
- .se_header = "Transaction ",
- .se_cmp = sort__transaction_cmp,
- .se_snprintf = hist_entry__transaction_snprintf,
- .se_width_idx = HISTC_TRANSACTION,
- };
- /* --sort symbol_size */
- static int64_t _sort__sym_size_cmp(struct symbol *sym_l, struct symbol *sym_r)
- {
- int64_t size_l = sym_l != NULL ? symbol__size(sym_l) : 0;
- int64_t size_r = sym_r != NULL ? symbol__size(sym_r) : 0;
- return size_l < size_r ? -1 :
- size_l == size_r ? 0 : 1;
- }
- static int64_t
- sort__sym_size_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return _sort__sym_size_cmp(right->ms.sym, left->ms.sym);
- }
- static int _hist_entry__sym_size_snprintf(struct symbol *sym, char *bf,
- size_t bf_size, unsigned int width)
- {
- if (sym)
- return repsep_snprintf(bf, bf_size, "%*d", width, symbol__size(sym));
- return repsep_snprintf(bf, bf_size, "%*s", width, "unknown");
- }
- static int hist_entry__sym_size_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return _hist_entry__sym_size_snprintf(he->ms.sym, bf, size, width);
- }
- struct sort_entry sort_sym_size = {
- .se_header = "Symbol size",
- .se_cmp = sort__sym_size_cmp,
- .se_snprintf = hist_entry__sym_size_snprintf,
- .se_width_idx = HISTC_SYM_SIZE,
- };
- /* --sort dso_size */
- static int64_t _sort__dso_size_cmp(struct map *map_l, struct map *map_r)
- {
- int64_t size_l = map_l != NULL ? map__size(map_l) : 0;
- int64_t size_r = map_r != NULL ? map__size(map_r) : 0;
- return size_l < size_r ? -1 :
- size_l == size_r ? 0 : 1;
- }
- static int64_t
- sort__dso_size_cmp(struct hist_entry *left, struct hist_entry *right)
- {
- return _sort__dso_size_cmp(right->ms.map, left->ms.map);
- }
- static int _hist_entry__dso_size_snprintf(struct map *map, char *bf,
- size_t bf_size, unsigned int width)
- {
- if (map && map->dso)
- return repsep_snprintf(bf, bf_size, "%*d", width,
- map__size(map));
- return repsep_snprintf(bf, bf_size, "%*s", width, "unknown");
- }
- static int hist_entry__dso_size_snprintf(struct hist_entry *he, char *bf,
- size_t size, unsigned int width)
- {
- return _hist_entry__dso_size_snprintf(he->ms.map, bf, size, width);
- }
- struct sort_entry sort_dso_size = {
- .se_header = "DSO size",
- .se_cmp = sort__dso_size_cmp,
- .se_snprintf = hist_entry__dso_size_snprintf,
- .se_width_idx = HISTC_DSO_SIZE,
- };
- struct sort_dimension {
- const char *name;
- struct sort_entry *entry;
- int taken;
- };
- #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
- static struct sort_dimension common_sort_dimensions[] = {
- DIM(SORT_PID, "pid", sort_thread),
- DIM(SORT_COMM, "comm", sort_comm),
- DIM(SORT_DSO, "dso", sort_dso),
- DIM(SORT_SYM, "symbol", sort_sym),
- DIM(SORT_PARENT, "parent", sort_parent),
- DIM(SORT_CPU, "cpu", sort_cpu),
- DIM(SORT_SOCKET, "socket", sort_socket),
- DIM(SORT_SRCLINE, "srcline", sort_srcline),
- DIM(SORT_SRCFILE, "srcfile", sort_srcfile),
- DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
- DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
- DIM(SORT_TRANSACTION, "transaction", sort_transaction),
- DIM(SORT_TRACE, "trace", sort_trace),
- DIM(SORT_SYM_SIZE, "symbol_size", sort_sym_size),
- DIM(SORT_DSO_SIZE, "dso_size", sort_dso_size),
- DIM(SORT_CGROUP, "cgroup", sort_cgroup),
- DIM(SORT_CGROUP_ID, "cgroup_id", sort_cgroup_id),
- DIM(SORT_SYM_IPC_NULL, "ipc_null", sort_sym_ipc_null),
- DIM(SORT_TIME, "time", sort_time),
- };
- #undef DIM
- #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
- static struct sort_dimension bstack_sort_dimensions[] = {
- DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
- DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
- DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
- DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
- DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
- DIM(SORT_IN_TX, "in_tx", sort_in_tx),
- DIM(SORT_ABORT, "abort", sort_abort),
- DIM(SORT_CYCLES, "cycles", sort_cycles),
- DIM(SORT_SRCLINE_FROM, "srcline_from", sort_srcline_from),
- DIM(SORT_SRCLINE_TO, "srcline_to", sort_srcline_to),
- DIM(SORT_SYM_IPC, "ipc_lbr", sort_sym_ipc),
- };
- #undef DIM
- #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
- static struct sort_dimension memory_sort_dimensions[] = {
- DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
- DIM(SORT_MEM_IADDR_SYMBOL, "symbol_iaddr", sort_mem_iaddr_sym),
- DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
- DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
- DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
- DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
- DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
- DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline),
- DIM(SORT_MEM_PHYS_DADDR, "phys_daddr", sort_mem_phys_daddr),
- };
- #undef DIM
- struct hpp_dimension {
- const char *name;
- struct perf_hpp_fmt *fmt;
- int taken;
- };
- #define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], }
- static struct hpp_dimension hpp_sort_dimensions[] = {
- DIM(PERF_HPP__OVERHEAD, "overhead"),
- DIM(PERF_HPP__OVERHEAD_SYS, "overhead_sys"),
- DIM(PERF_HPP__OVERHEAD_US, "overhead_us"),
- DIM(PERF_HPP__OVERHEAD_GUEST_SYS, "overhead_guest_sys"),
- DIM(PERF_HPP__OVERHEAD_GUEST_US, "overhead_guest_us"),
- DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"),
- DIM(PERF_HPP__SAMPLES, "sample"),
- DIM(PERF_HPP__PERIOD, "period"),
- };
- #undef DIM
- struct hpp_sort_entry {
- struct perf_hpp_fmt hpp;
- struct sort_entry *se;
- };
- void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
- {
- struct hpp_sort_entry *hse;
- if (!perf_hpp__is_sort_entry(fmt))
- return;
- hse = container_of(fmt, struct hpp_sort_entry, hpp);
- hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
- }
- static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
- struct hists *hists, int line __maybe_unused,
- int *span __maybe_unused)
- {
- struct hpp_sort_entry *hse;
- size_t len = fmt->user_len;
- hse = container_of(fmt, struct hpp_sort_entry, hpp);
- if (!len)
- len = hists__col_len(hists, hse->se->se_width_idx);
- return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
- }
- static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
- struct perf_hpp *hpp __maybe_unused,
- struct hists *hists)
- {
- struct hpp_sort_entry *hse;
- size_t len = fmt->user_len;
- hse = container_of(fmt, struct hpp_sort_entry, hpp);
- if (!len)
- len = hists__col_len(hists, hse->se->se_width_idx);
- return len;
- }
- static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
- struct hist_entry *he)
- {
- struct hpp_sort_entry *hse;
- size_t len = fmt->user_len;
- hse = container_of(fmt, struct hpp_sort_entry, hpp);
- if (!len)
- len = hists__col_len(he->hists, hse->se->se_width_idx);
- return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
- }
- static int64_t __sort__hpp_cmp(struct perf_hpp_fmt *fmt,
- struct hist_entry *a, struct hist_entry *b)
- {
- struct hpp_sort_entry *hse;
- hse = container_of(fmt, struct hpp_sort_entry, hpp);
- return hse->se->se_cmp(a, b);
- }
- static int64_t __sort__hpp_collapse(struct perf_hpp_fmt *fmt,
- struct hist_entry *a, struct hist_entry *b)
- {
- struct hpp_sort_entry *hse;
- int64_t (*collapse_fn)(struct hist_entry *, struct hist_entry *);
- hse = container_of(fmt, struct hpp_sort_entry, hpp);
- collapse_fn = hse->se->se_collapse ?: hse->se->se_cmp;
- return collapse_fn(a, b);
- }
- static int64_t __sort__hpp_sort(struct perf_hpp_fmt *fmt,
- struct hist_entry *a, struct hist_entry *b)
- {
- struct hpp_sort_entry *hse;
- int64_t (*sort_fn)(struct hist_entry *, struct hist_entry *);
- hse = container_of(fmt, struct hpp_sort_entry, hpp);
- sort_fn = hse->se->se_sort ?: hse->se->se_cmp;
- return sort_fn(a, b);
- }
- bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)
- {
- return format->header == __sort__hpp_header;
- }
- #define MK_SORT_ENTRY_CHK(key) \
- bool perf_hpp__is_ ## key ## _entry(struct perf_hpp_fmt *fmt) \
- { \
- struct hpp_sort_entry *hse; \
- \
- if (!perf_hpp__is_sort_entry(fmt)) \
- return false; \
- \
- hse = container_of(fmt, struct hpp_sort_entry, hpp); \
- return hse->se == &sort_ ## key ; \
- }
- MK_SORT_ENTRY_CHK(trace)
- MK_SORT_ENTRY_CHK(srcline)
- MK_SORT_ENTRY_CHK(srcfile)
- MK_SORT_ENTRY_CHK(thread)
- MK_SORT_ENTRY_CHK(comm)
- MK_SORT_ENTRY_CHK(dso)
- MK_SORT_ENTRY_CHK(sym)
- static bool __sort__hpp_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
- {
- struct hpp_sort_entry *hse_a;
- struct hpp_sort_entry *hse_b;
- if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b))
- return false;
- hse_a = container_of(a, struct hpp_sort_entry, hpp);
- hse_b = container_of(b, struct hpp_sort_entry, hpp);
- return hse_a->se == hse_b->se;
- }
- static void hse_free(struct perf_hpp_fmt *fmt)
- {
- struct hpp_sort_entry *hse;
- hse = container_of(fmt, struct hpp_sort_entry, hpp);
- free(hse);
- }
- static struct hpp_sort_entry *
- __sort_dimension__alloc_hpp(struct sort_dimension *sd, int level)
- {
- struct hpp_sort_entry *hse;
- hse = malloc(sizeof(*hse));
- if (hse == NULL) {
- pr_err("Memory allocation failed\n");
- return NULL;
- }
- hse->se = sd->entry;
- hse->hpp.name = sd->entry->se_header;
- hse->hpp.header = __sort__hpp_header;
- hse->hpp.width = __sort__hpp_width;
- hse->hpp.entry = __sort__hpp_entry;
- hse->hpp.color = NULL;
- hse->hpp.cmp = __sort__hpp_cmp;
- hse->hpp.collapse = __sort__hpp_collapse;
- hse->hpp.sort = __sort__hpp_sort;
- hse->hpp.equal = __sort__hpp_equal;
- hse->hpp.free = hse_free;
- INIT_LIST_HEAD(&hse->hpp.list);
- INIT_LIST_HEAD(&hse->hpp.sort_list);
- hse->hpp.elide = false;
- hse->hpp.len = 0;
- hse->hpp.user_len = 0;
- hse->hpp.level = level;
- return hse;
- }
- static void hpp_free(struct perf_hpp_fmt *fmt)
- {
- free(fmt);
- }
- static struct perf_hpp_fmt *__hpp_dimension__alloc_hpp(struct hpp_dimension *hd,
- int level)
- {
- struct perf_hpp_fmt *fmt;
- fmt =…
Large files files are truncated, but you can click here to view the full file