9c2b957db1
Pull perf events changes for v3.4 from Ingo Molnar: - New "hardware based branch profiling" feature both on the kernel and the tooling side, on CPUs that support it. (modern x86 Intel CPUs with the 'LBR' hardware feature currently.) This new feature is basically a sophisticated 'magnifying glass' for branch execution - something that is pretty difficult to extract from regular, function histogram centric profiles. The simplest mode is activated via 'perf record -b', and the result looks like this in perf report: $ perf record -b any_call,u -e cycles:u branchy $ perf report -b --sort=symbol 52.34% [.] main [.] f1 24.04% [.] f1 [.] f3 23.60% [.] f1 [.] f2 0.01% [k] _IO_new_file_xsputn [k] _IO_file_overflow 0.01% [k] _IO_vfprintf_internal [k] _IO_new_file_xsputn 0.01% [k] _IO_vfprintf_internal [k] strchrnul 0.01% [k] __printf [k] _IO_vfprintf_internal 0.01% [k] main [k] __printf This output shows from/to branch columns and shows the highest percentage (from,to) jump combinations - i.e. the most likely taken branches in the system. "branches" can also include function calls and any other synchronous and asynchronous transitions of the instruction pointer that are not 'next instruction' - such as system calls, traps, interrupts, etc. This feature comes with (hopefully intuitive) flat ascii and TUI support in perf report. - Various 'perf annotate' visual improvements for us assembly junkies. It will now recognize function calls in the TUI and by hitting enter you can follow the call (recursively) and back, amongst other improvements. - Multiple threads/processes recording support in perf record, perf stat, perf top - which is activated via a comma-list of PIDs: perf top -p 21483,21485 perf stat -p 21483,21485 -ddd perf record -p 21483,21485 - Support for per UID views, via the --uid paramter to perf top, perf report, etc. For example 'perf top --uid mingo' will only show the tasks that I am running, excluding other users, root, etc. - Jump label restructurings and improvements - this includes the factoring out of the (hopefully much clearer) include/linux/static_key.h generic facility: struct static_key key = STATIC_KEY_INIT_FALSE; ... if (static_key_false(&key)) do unlikely code else do likely code ... static_key_slow_inc(); ... static_key_slow_inc(); ... The static_key_false() branch will be generated into the code with as little impact to the likely code path as possible. the static_key_slow_*() APIs flip the branch via live kernel code patching. This facility can now be used more widely within the kernel to micro-optimize hot branches whose likelihood matches the static-key usage and fast/slow cost patterns. - SW function tracer improvements: perf support and filtering support. - Various hardenings of the perf.data ABI, to make older perf.data's smoother on newer tool versions, to make new features integrate more smoothly, to support cross-endian recording/analyzing workflows better, etc. - Restructuring of the kprobes code, the splitting out of 'optprobes', and a corner case bugfix. - Allow the tracing of kernel console output (printk). - Improvements/fixes to user-space RDPMC support, allowing user-space self-profiling code to extract PMU counts without performing any system calls, while playing nice with the kernel side. - 'perf bench' improvements - ... and lots of internal restructurings, cleanups and fixes that made these features possible. And, as usual this list is incomplete as there were also lots of other improvements * 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (120 commits) perf report: Fix annotate double quit issue in branch view mode perf report: Remove duplicate annotate choice in branch view mode perf/x86: Prettify pmu config literals perf report: Enable TUI in branch view mode perf report: Auto-detect branch stack sampling mode perf record: Add HEADER_BRANCH_STACK tag perf record: Provide default branch stack sampling mode option perf tools: Make perf able to read files from older ABIs perf tools: Fix ABI compatibility bug in print_event_desc() perf tools: Enable reading of perf.data files from different ABI rev perf: Add ABI reference sizes perf report: Add support for taken branch sampling perf record: Add support for sampling taken branch perf tools: Add code to support PERF_SAMPLE_BRANCH_STACK x86/kprobes: Split out optprobe related code to kprobes-opt.c x86/kprobes: Fix a bug which can modify kernel code permanently x86/kprobes: Fix instruction recovery on optimized path perf: Add callback to flush branch_stack on context switch perf: Disable PERF_SAMPLE_BRANCH_* when not supported perf/x86: Add LBR software filter support for Intel CPUs ...
1286 lines
30 KiB
C
1286 lines
30 KiB
C
#include "annotate.h"
|
|
#include "util.h"
|
|
#include "build-id.h"
|
|
#include "hist.h"
|
|
#include "session.h"
|
|
#include "sort.h"
|
|
#include <math.h>
|
|
|
|
static bool hists__filter_entry_by_dso(struct hists *hists,
|
|
struct hist_entry *he);
|
|
static bool hists__filter_entry_by_thread(struct hists *hists,
|
|
struct hist_entry *he);
|
|
|
|
enum hist_filter {
|
|
HIST_FILTER__DSO,
|
|
HIST_FILTER__THREAD,
|
|
HIST_FILTER__PARENT,
|
|
};
|
|
|
|
struct callchain_param callchain_param = {
|
|
.mode = CHAIN_GRAPH_REL,
|
|
.min_percent = 0.5,
|
|
.order = ORDER_CALLEE
|
|
};
|
|
|
|
u16 hists__col_len(struct hists *hists, enum hist_column col)
|
|
{
|
|
return hists->col_len[col];
|
|
}
|
|
|
|
void hists__set_col_len(struct hists *hists, enum hist_column col, u16 len)
|
|
{
|
|
hists->col_len[col] = len;
|
|
}
|
|
|
|
bool hists__new_col_len(struct hists *hists, enum hist_column col, u16 len)
|
|
{
|
|
if (len > hists__col_len(hists, col)) {
|
|
hists__set_col_len(hists, col, len);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void hists__reset_col_len(struct hists *hists)
|
|
{
|
|
enum hist_column col;
|
|
|
|
for (col = 0; col < HISTC_NR_COLS; ++col)
|
|
hists__set_col_len(hists, col, 0);
|
|
}
|
|
|
|
static void hists__set_unres_dso_col_len(struct hists *hists, int dso)
|
|
{
|
|
const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
|
|
|
|
if (hists__col_len(hists, dso) < unresolved_col_width &&
|
|
!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
|
|
!symbol_conf.dso_list)
|
|
hists__set_col_len(hists, dso, unresolved_col_width);
|
|
}
|
|
|
|
static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
|
|
{
|
|
const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
|
|
u16 len;
|
|
|
|
if (h->ms.sym)
|
|
hists__new_col_len(hists, HISTC_SYMBOL, h->ms.sym->namelen + 4);
|
|
else
|
|
hists__set_unres_dso_col_len(hists, HISTC_DSO);
|
|
|
|
len = thread__comm_len(h->thread);
|
|
if (hists__new_col_len(hists, HISTC_COMM, len))
|
|
hists__set_col_len(hists, HISTC_THREAD, len + 6);
|
|
|
|
if (h->ms.map) {
|
|
len = dso__name_len(h->ms.map->dso);
|
|
hists__new_col_len(hists, HISTC_DSO, len);
|
|
}
|
|
|
|
if (h->branch_info) {
|
|
int symlen;
|
|
/*
|
|
* +4 accounts for '[x] ' priv level info
|
|
* +2 account of 0x prefix on raw addresses
|
|
*/
|
|
if (h->branch_info->from.sym) {
|
|
symlen = (int)h->branch_info->from.sym->namelen + 4;
|
|
hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
|
|
|
|
symlen = dso__name_len(h->branch_info->from.map->dso);
|
|
hists__new_col_len(hists, HISTC_DSO_FROM, symlen);
|
|
} else {
|
|
symlen = unresolved_col_width + 4 + 2;
|
|
hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
|
|
hists__set_unres_dso_col_len(hists, HISTC_DSO_FROM);
|
|
}
|
|
|
|
if (h->branch_info->to.sym) {
|
|
symlen = (int)h->branch_info->to.sym->namelen + 4;
|
|
hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
|
|
|
|
symlen = dso__name_len(h->branch_info->to.map->dso);
|
|
hists__new_col_len(hists, HISTC_DSO_TO, symlen);
|
|
} else {
|
|
symlen = unresolved_col_width + 4 + 2;
|
|
hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
|
|
hists__set_unres_dso_col_len(hists, HISTC_DSO_TO);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void hist_entry__add_cpumode_period(struct hist_entry *he,
|
|
unsigned int cpumode, u64 period)
|
|
{
|
|
switch (cpumode) {
|
|
case PERF_RECORD_MISC_KERNEL:
|
|
he->period_sys += period;
|
|
break;
|
|
case PERF_RECORD_MISC_USER:
|
|
he->period_us += period;
|
|
break;
|
|
case PERF_RECORD_MISC_GUEST_KERNEL:
|
|
he->period_guest_sys += period;
|
|
break;
|
|
case PERF_RECORD_MISC_GUEST_USER:
|
|
he->period_guest_us += period;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void hist_entry__decay(struct hist_entry *he)
|
|
{
|
|
he->period = (he->period * 7) / 8;
|
|
he->nr_events = (he->nr_events * 7) / 8;
|
|
}
|
|
|
|
static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
|
|
{
|
|
u64 prev_period = he->period;
|
|
|
|
if (prev_period == 0)
|
|
return true;
|
|
|
|
hist_entry__decay(he);
|
|
|
|
if (!he->filtered)
|
|
hists->stats.total_period -= prev_period - he->period;
|
|
|
|
return he->period == 0;
|
|
}
|
|
|
|
static void __hists__decay_entries(struct hists *hists, bool zap_user,
|
|
bool zap_kernel, bool threaded)
|
|
{
|
|
struct rb_node *next = rb_first(&hists->entries);
|
|
struct hist_entry *n;
|
|
|
|
while (next) {
|
|
n = rb_entry(next, struct hist_entry, rb_node);
|
|
next = rb_next(&n->rb_node);
|
|
/*
|
|
* We may be annotating this, for instance, so keep it here in
|
|
* case some it gets new samples, we'll eventually free it when
|
|
* the user stops browsing and it agains gets fully decayed.
|
|
*/
|
|
if (((zap_user && n->level == '.') ||
|
|
(zap_kernel && n->level != '.') ||
|
|
hists__decay_entry(hists, n)) &&
|
|
!n->used) {
|
|
rb_erase(&n->rb_node, &hists->entries);
|
|
|
|
if (sort__need_collapse || threaded)
|
|
rb_erase(&n->rb_node_in, &hists->entries_collapsed);
|
|
|
|
hist_entry__free(n);
|
|
--hists->nr_entries;
|
|
}
|
|
}
|
|
}
|
|
|
|
void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
|
|
{
|
|
return __hists__decay_entries(hists, zap_user, zap_kernel, false);
|
|
}
|
|
|
|
void hists__decay_entries_threaded(struct hists *hists,
|
|
bool zap_user, bool zap_kernel)
|
|
{
|
|
return __hists__decay_entries(hists, zap_user, zap_kernel, true);
|
|
}
|
|
|
|
/*
|
|
* histogram, sorted on item, collects periods
|
|
*/
|
|
|
|
static struct hist_entry *hist_entry__new(struct hist_entry *template)
|
|
{
|
|
size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_root) : 0;
|
|
struct hist_entry *he = malloc(sizeof(*he) + callchain_size);
|
|
|
|
if (he != NULL) {
|
|
*he = *template;
|
|
he->nr_events = 1;
|
|
if (he->ms.map)
|
|
he->ms.map->referenced = true;
|
|
if (symbol_conf.use_callchain)
|
|
callchain_init(he->callchain);
|
|
}
|
|
|
|
return he;
|
|
}
|
|
|
|
static void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h)
|
|
{
|
|
if (!h->filtered) {
|
|
hists__calc_col_len(hists, h);
|
|
++hists->nr_entries;
|
|
hists->stats.total_period += h->period;
|
|
}
|
|
}
|
|
|
|
static u8 symbol__parent_filter(const struct symbol *parent)
|
|
{
|
|
if (symbol_conf.exclude_other && parent == NULL)
|
|
return 1 << HIST_FILTER__PARENT;
|
|
return 0;
|
|
}
|
|
|
|
static struct hist_entry *add_hist_entry(struct hists *hists,
|
|
struct hist_entry *entry,
|
|
struct addr_location *al,
|
|
u64 period)
|
|
{
|
|
struct rb_node **p;
|
|
struct rb_node *parent = NULL;
|
|
struct hist_entry *he;
|
|
int cmp;
|
|
|
|
pthread_mutex_lock(&hists->lock);
|
|
|
|
p = &hists->entries_in->rb_node;
|
|
|
|
while (*p != NULL) {
|
|
parent = *p;
|
|
he = rb_entry(parent, struct hist_entry, rb_node_in);
|
|
|
|
cmp = hist_entry__cmp(entry, he);
|
|
|
|
if (!cmp) {
|
|
he->period += period;
|
|
++he->nr_events;
|
|
goto out;
|
|
}
|
|
|
|
if (cmp < 0)
|
|
p = &(*p)->rb_left;
|
|
else
|
|
p = &(*p)->rb_right;
|
|
}
|
|
|
|
he = hist_entry__new(entry);
|
|
if (!he)
|
|
goto out_unlock;
|
|
|
|
rb_link_node(&he->rb_node_in, parent, p);
|
|
rb_insert_color(&he->rb_node_in, hists->entries_in);
|
|
out:
|
|
hist_entry__add_cpumode_period(he, al->cpumode, period);
|
|
out_unlock:
|
|
pthread_mutex_unlock(&hists->lock);
|
|
return he;
|
|
}
|
|
|
|
struct hist_entry *__hists__add_branch_entry(struct hists *self,
|
|
struct addr_location *al,
|
|
struct symbol *sym_parent,
|
|
struct branch_info *bi,
|
|
u64 period)
|
|
{
|
|
struct hist_entry entry = {
|
|
.thread = al->thread,
|
|
.ms = {
|
|
.map = bi->to.map,
|
|
.sym = bi->to.sym,
|
|
},
|
|
.cpu = al->cpu,
|
|
.ip = bi->to.addr,
|
|
.level = al->level,
|
|
.period = period,
|
|
.parent = sym_parent,
|
|
.filtered = symbol__parent_filter(sym_parent),
|
|
.branch_info = bi,
|
|
};
|
|
|
|
return add_hist_entry(self, &entry, al, period);
|
|
}
|
|
|
|
struct hist_entry *__hists__add_entry(struct hists *self,
|
|
struct addr_location *al,
|
|
struct symbol *sym_parent, u64 period)
|
|
{
|
|
struct hist_entry entry = {
|
|
.thread = al->thread,
|
|
.ms = {
|
|
.map = al->map,
|
|
.sym = al->sym,
|
|
},
|
|
.cpu = al->cpu,
|
|
.ip = al->addr,
|
|
.level = al->level,
|
|
.period = period,
|
|
.parent = sym_parent,
|
|
.filtered = symbol__parent_filter(sym_parent),
|
|
};
|
|
|
|
return add_hist_entry(self, &entry, al, period);
|
|
}
|
|
|
|
int64_t
|
|
hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
|
|
{
|
|
struct sort_entry *se;
|
|
int64_t cmp = 0;
|
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
cmp = se->se_cmp(left, right);
|
|
if (cmp)
|
|
break;
|
|
}
|
|
|
|
return cmp;
|
|
}
|
|
|
|
int64_t
|
|
hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
|
|
{
|
|
struct sort_entry *se;
|
|
int64_t cmp = 0;
|
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
int64_t (*f)(struct hist_entry *, struct hist_entry *);
|
|
|
|
f = se->se_collapse ?: se->se_cmp;
|
|
|
|
cmp = f(left, right);
|
|
if (cmp)
|
|
break;
|
|
}
|
|
|
|
return cmp;
|
|
}
|
|
|
|
void hist_entry__free(struct hist_entry *he)
|
|
{
|
|
free(he);
|
|
}
|
|
|
|
/*
|
|
* collapse the histogram
|
|
*/
|
|
|
|
static bool hists__collapse_insert_entry(struct hists *hists,
|
|
struct rb_root *root,
|
|
struct hist_entry *he)
|
|
{
|
|
struct rb_node **p = &root->rb_node;
|
|
struct rb_node *parent = NULL;
|
|
struct hist_entry *iter;
|
|
int64_t cmp;
|
|
|
|
while (*p != NULL) {
|
|
parent = *p;
|
|
iter = rb_entry(parent, struct hist_entry, rb_node_in);
|
|
|
|
cmp = hist_entry__collapse(iter, he);
|
|
|
|
if (!cmp) {
|
|
iter->period += he->period;
|
|
iter->nr_events += he->nr_events;
|
|
if (symbol_conf.use_callchain) {
|
|
callchain_cursor_reset(&hists->callchain_cursor);
|
|
callchain_merge(&hists->callchain_cursor, iter->callchain,
|
|
he->callchain);
|
|
}
|
|
hist_entry__free(he);
|
|
return false;
|
|
}
|
|
|
|
if (cmp < 0)
|
|
p = &(*p)->rb_left;
|
|
else
|
|
p = &(*p)->rb_right;
|
|
}
|
|
|
|
rb_link_node(&he->rb_node_in, parent, p);
|
|
rb_insert_color(&he->rb_node_in, root);
|
|
return true;
|
|
}
|
|
|
|
static struct rb_root *hists__get_rotate_entries_in(struct hists *hists)
|
|
{
|
|
struct rb_root *root;
|
|
|
|
pthread_mutex_lock(&hists->lock);
|
|
|
|
root = hists->entries_in;
|
|
if (++hists->entries_in > &hists->entries_in_array[1])
|
|
hists->entries_in = &hists->entries_in_array[0];
|
|
|
|
pthread_mutex_unlock(&hists->lock);
|
|
|
|
return root;
|
|
}
|
|
|
|
static void hists__apply_filters(struct hists *hists, struct hist_entry *he)
|
|
{
|
|
hists__filter_entry_by_dso(hists, he);
|
|
hists__filter_entry_by_thread(hists, he);
|
|
}
|
|
|
|
static void __hists__collapse_resort(struct hists *hists, bool threaded)
|
|
{
|
|
struct rb_root *root;
|
|
struct rb_node *next;
|
|
struct hist_entry *n;
|
|
|
|
if (!sort__need_collapse && !threaded)
|
|
return;
|
|
|
|
root = hists__get_rotate_entries_in(hists);
|
|
next = rb_first(root);
|
|
|
|
while (next) {
|
|
n = rb_entry(next, struct hist_entry, rb_node_in);
|
|
next = rb_next(&n->rb_node_in);
|
|
|
|
rb_erase(&n->rb_node_in, root);
|
|
if (hists__collapse_insert_entry(hists, &hists->entries_collapsed, n)) {
|
|
/*
|
|
* If it wasn't combined with one of the entries already
|
|
* collapsed, we need to apply the filters that may have
|
|
* been set by, say, the hist_browser.
|
|
*/
|
|
hists__apply_filters(hists, n);
|
|
}
|
|
}
|
|
}
|
|
|
|
void hists__collapse_resort(struct hists *hists)
|
|
{
|
|
return __hists__collapse_resort(hists, false);
|
|
}
|
|
|
|
void hists__collapse_resort_threaded(struct hists *hists)
|
|
{
|
|
return __hists__collapse_resort(hists, true);
|
|
}
|
|
|
|
/*
|
|
* reverse the map, sort on period.
|
|
*/
|
|
|
|
static void __hists__insert_output_entry(struct rb_root *entries,
|
|
struct hist_entry *he,
|
|
u64 min_callchain_hits)
|
|
{
|
|
struct rb_node **p = &entries->rb_node;
|
|
struct rb_node *parent = NULL;
|
|
struct hist_entry *iter;
|
|
|
|
if (symbol_conf.use_callchain)
|
|
callchain_param.sort(&he->sorted_chain, he->callchain,
|
|
min_callchain_hits, &callchain_param);
|
|
|
|
while (*p != NULL) {
|
|
parent = *p;
|
|
iter = rb_entry(parent, struct hist_entry, rb_node);
|
|
|
|
if (he->period > iter->period)
|
|
p = &(*p)->rb_left;
|
|
else
|
|
p = &(*p)->rb_right;
|
|
}
|
|
|
|
rb_link_node(&he->rb_node, parent, p);
|
|
rb_insert_color(&he->rb_node, entries);
|
|
}
|
|
|
|
static void __hists__output_resort(struct hists *hists, bool threaded)
|
|
{
|
|
struct rb_root *root;
|
|
struct rb_node *next;
|
|
struct hist_entry *n;
|
|
u64 min_callchain_hits;
|
|
|
|
min_callchain_hits = hists->stats.total_period * (callchain_param.min_percent / 100);
|
|
|
|
if (sort__need_collapse || threaded)
|
|
root = &hists->entries_collapsed;
|
|
else
|
|
root = hists->entries_in;
|
|
|
|
next = rb_first(root);
|
|
hists->entries = RB_ROOT;
|
|
|
|
hists->nr_entries = 0;
|
|
hists->stats.total_period = 0;
|
|
hists__reset_col_len(hists);
|
|
|
|
while (next) {
|
|
n = rb_entry(next, struct hist_entry, rb_node_in);
|
|
next = rb_next(&n->rb_node_in);
|
|
|
|
__hists__insert_output_entry(&hists->entries, n, min_callchain_hits);
|
|
hists__inc_nr_entries(hists, n);
|
|
}
|
|
}
|
|
|
|
void hists__output_resort(struct hists *hists)
|
|
{
|
|
return __hists__output_resort(hists, false);
|
|
}
|
|
|
|
void hists__output_resort_threaded(struct hists *hists)
|
|
{
|
|
return __hists__output_resort(hists, true);
|
|
}
|
|
|
|
static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
|
|
{
|
|
int i;
|
|
int ret = fprintf(fp, " ");
|
|
|
|
for (i = 0; i < left_margin; i++)
|
|
ret += fprintf(fp, " ");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
|
|
int left_margin)
|
|
{
|
|
int i;
|
|
size_t ret = callchain__fprintf_left_margin(fp, left_margin);
|
|
|
|
for (i = 0; i < depth; i++)
|
|
if (depth_mask & (1 << i))
|
|
ret += fprintf(fp, "| ");
|
|
else
|
|
ret += fprintf(fp, " ");
|
|
|
|
ret += fprintf(fp, "\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
|
|
int depth, int depth_mask, int period,
|
|
u64 total_samples, u64 hits,
|
|
int left_margin)
|
|
{
|
|
int i;
|
|
size_t ret = 0;
|
|
|
|
ret += callchain__fprintf_left_margin(fp, left_margin);
|
|
for (i = 0; i < depth; i++) {
|
|
if (depth_mask & (1 << i))
|
|
ret += fprintf(fp, "|");
|
|
else
|
|
ret += fprintf(fp, " ");
|
|
if (!period && i == depth - 1) {
|
|
double percent;
|
|
|
|
percent = hits * 100.0 / total_samples;
|
|
ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
|
|
} else
|
|
ret += fprintf(fp, "%s", " ");
|
|
}
|
|
if (chain->ms.sym)
|
|
ret += fprintf(fp, "%s\n", chain->ms.sym->name);
|
|
else
|
|
ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static struct symbol *rem_sq_bracket;
|
|
static struct callchain_list rem_hits;
|
|
|
|
static void init_rem_hits(void)
|
|
{
|
|
rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
|
|
if (!rem_sq_bracket) {
|
|
fprintf(stderr, "Not enough memory to display remaining hits\n");
|
|
return;
|
|
}
|
|
|
|
strcpy(rem_sq_bracket->name, "[...]");
|
|
rem_hits.ms.sym = rem_sq_bracket;
|
|
}
|
|
|
|
static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
|
|
u64 total_samples, int depth,
|
|
int depth_mask, int left_margin)
|
|
{
|
|
struct rb_node *node, *next;
|
|
struct callchain_node *child;
|
|
struct callchain_list *chain;
|
|
int new_depth_mask = depth_mask;
|
|
u64 new_total;
|
|
u64 remaining;
|
|
size_t ret = 0;
|
|
int i;
|
|
uint entries_printed = 0;
|
|
|
|
if (callchain_param.mode == CHAIN_GRAPH_REL)
|
|
new_total = self->children_hit;
|
|
else
|
|
new_total = total_samples;
|
|
|
|
remaining = new_total;
|
|
|
|
node = rb_first(&self->rb_root);
|
|
while (node) {
|
|
u64 cumul;
|
|
|
|
child = rb_entry(node, struct callchain_node, rb_node);
|
|
cumul = callchain_cumul_hits(child);
|
|
remaining -= cumul;
|
|
|
|
/*
|
|
* The depth mask manages the output of pipes that show
|
|
* the depth. We don't want to keep the pipes of the current
|
|
* level for the last child of this depth.
|
|
* Except if we have remaining filtered hits. They will
|
|
* supersede the last child
|
|
*/
|
|
next = rb_next(node);
|
|
if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
|
|
new_depth_mask &= ~(1 << (depth - 1));
|
|
|
|
/*
|
|
* But we keep the older depth mask for the line separator
|
|
* to keep the level link until we reach the last child
|
|
*/
|
|
ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
|
|
left_margin);
|
|
i = 0;
|
|
list_for_each_entry(chain, &child->val, list) {
|
|
ret += ipchain__fprintf_graph(fp, chain, depth,
|
|
new_depth_mask, i++,
|
|
new_total,
|
|
cumul,
|
|
left_margin);
|
|
}
|
|
ret += __callchain__fprintf_graph(fp, child, new_total,
|
|
depth + 1,
|
|
new_depth_mask | (1 << depth),
|
|
left_margin);
|
|
node = next;
|
|
if (++entries_printed == callchain_param.print_limit)
|
|
break;
|
|
}
|
|
|
|
if (callchain_param.mode == CHAIN_GRAPH_REL &&
|
|
remaining && remaining != new_total) {
|
|
|
|
if (!rem_sq_bracket)
|
|
return ret;
|
|
|
|
new_depth_mask &= ~(1 << (depth - 1));
|
|
|
|
ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
|
|
new_depth_mask, 0, new_total,
|
|
remaining, left_margin);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
|
|
u64 total_samples, int left_margin)
|
|
{
|
|
struct callchain_list *chain;
|
|
bool printed = false;
|
|
int i = 0;
|
|
int ret = 0;
|
|
u32 entries_printed = 0;
|
|
|
|
list_for_each_entry(chain, &self->val, list) {
|
|
if (!i++ && sort__first_dimension == SORT_SYM)
|
|
continue;
|
|
|
|
if (!printed) {
|
|
ret += callchain__fprintf_left_margin(fp, left_margin);
|
|
ret += fprintf(fp, "|\n");
|
|
ret += callchain__fprintf_left_margin(fp, left_margin);
|
|
ret += fprintf(fp, "---");
|
|
|
|
left_margin += 3;
|
|
printed = true;
|
|
} else
|
|
ret += callchain__fprintf_left_margin(fp, left_margin);
|
|
|
|
if (chain->ms.sym)
|
|
ret += fprintf(fp, " %s\n", chain->ms.sym->name);
|
|
else
|
|
ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
|
|
|
|
if (++entries_printed == callchain_param.print_limit)
|
|
break;
|
|
}
|
|
|
|
ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
|
|
u64 total_samples)
|
|
{
|
|
struct callchain_list *chain;
|
|
size_t ret = 0;
|
|
|
|
if (!self)
|
|
return 0;
|
|
|
|
ret += callchain__fprintf_flat(fp, self->parent, total_samples);
|
|
|
|
|
|
list_for_each_entry(chain, &self->val, list) {
|
|
if (chain->ip >= PERF_CONTEXT_MAX)
|
|
continue;
|
|
if (chain->ms.sym)
|
|
ret += fprintf(fp, " %s\n", chain->ms.sym->name);
|
|
else
|
|
ret += fprintf(fp, " %p\n",
|
|
(void *)(long)chain->ip);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
|
|
u64 total_samples, int left_margin,
|
|
FILE *fp)
|
|
{
|
|
struct rb_node *rb_node;
|
|
struct callchain_node *chain;
|
|
size_t ret = 0;
|
|
u32 entries_printed = 0;
|
|
|
|
rb_node = rb_first(&he->sorted_chain);
|
|
while (rb_node) {
|
|
double percent;
|
|
|
|
chain = rb_entry(rb_node, struct callchain_node, rb_node);
|
|
percent = chain->hit * 100.0 / total_samples;
|
|
switch (callchain_param.mode) {
|
|
case CHAIN_FLAT:
|
|
ret += percent_color_fprintf(fp, " %6.2f%%\n",
|
|
percent);
|
|
ret += callchain__fprintf_flat(fp, chain, total_samples);
|
|
break;
|
|
case CHAIN_GRAPH_ABS: /* Falldown */
|
|
case CHAIN_GRAPH_REL:
|
|
ret += callchain__fprintf_graph(fp, chain, total_samples,
|
|
left_margin);
|
|
case CHAIN_NONE:
|
|
default:
|
|
break;
|
|
}
|
|
ret += fprintf(fp, "\n");
|
|
if (++entries_printed == callchain_param.print_limit)
|
|
break;
|
|
rb_node = rb_next(rb_node);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void hists__output_recalc_col_len(struct hists *hists, int max_rows)
|
|
{
|
|
struct rb_node *next = rb_first(&hists->entries);
|
|
struct hist_entry *n;
|
|
int row = 0;
|
|
|
|
hists__reset_col_len(hists);
|
|
|
|
while (next && row++ < max_rows) {
|
|
n = rb_entry(next, struct hist_entry, rb_node);
|
|
if (!n->filtered)
|
|
hists__calc_col_len(hists, n);
|
|
next = rb_next(&n->rb_node);
|
|
}
|
|
}
|
|
|
|
static int hist_entry__pcnt_snprintf(struct hist_entry *he, char *s,
|
|
size_t size, struct hists *pair_hists,
|
|
bool show_displacement, long displacement,
|
|
bool color, u64 total_period)
|
|
{
|
|
u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
|
|
u64 nr_events;
|
|
const char *sep = symbol_conf.field_sep;
|
|
int ret;
|
|
|
|
if (symbol_conf.exclude_other && !he->parent)
|
|
return 0;
|
|
|
|
if (pair_hists) {
|
|
period = he->pair ? he->pair->period : 0;
|
|
nr_events = he->pair ? he->pair->nr_events : 0;
|
|
total = pair_hists->stats.total_period;
|
|
period_sys = he->pair ? he->pair->period_sys : 0;
|
|
period_us = he->pair ? he->pair->period_us : 0;
|
|
period_guest_sys = he->pair ? he->pair->period_guest_sys : 0;
|
|
period_guest_us = he->pair ? he->pair->period_guest_us : 0;
|
|
} else {
|
|
period = he->period;
|
|
nr_events = he->nr_events;
|
|
total = total_period;
|
|
period_sys = he->period_sys;
|
|
period_us = he->period_us;
|
|
period_guest_sys = he->period_guest_sys;
|
|
period_guest_us = he->period_guest_us;
|
|
}
|
|
|
|
if (total) {
|
|
if (color)
|
|
ret = percent_color_snprintf(s, size,
|
|
sep ? "%.2f" : " %6.2f%%",
|
|
(period * 100.0) / total);
|
|
else
|
|
ret = scnprintf(s, size, sep ? "%.2f" : " %6.2f%%",
|
|
(period * 100.0) / total);
|
|
if (symbol_conf.show_cpu_utilization) {
|
|
ret += percent_color_snprintf(s + ret, size - ret,
|
|
sep ? "%.2f" : " %6.2f%%",
|
|
(period_sys * 100.0) / total);
|
|
ret += percent_color_snprintf(s + ret, size - ret,
|
|
sep ? "%.2f" : " %6.2f%%",
|
|
(period_us * 100.0) / total);
|
|
if (perf_guest) {
|
|
ret += percent_color_snprintf(s + ret,
|
|
size - ret,
|
|
sep ? "%.2f" : " %6.2f%%",
|
|
(period_guest_sys * 100.0) /
|
|
total);
|
|
ret += percent_color_snprintf(s + ret,
|
|
size - ret,
|
|
sep ? "%.2f" : " %6.2f%%",
|
|
(period_guest_us * 100.0) /
|
|
total);
|
|
}
|
|
}
|
|
} else
|
|
ret = scnprintf(s, size, sep ? "%" PRIu64 : "%12" PRIu64 " ", period);
|
|
|
|
if (symbol_conf.show_nr_samples) {
|
|
if (sep)
|
|
ret += scnprintf(s + ret, size - ret, "%c%" PRIu64, *sep, nr_events);
|
|
else
|
|
ret += scnprintf(s + ret, size - ret, "%11" PRIu64, nr_events);
|
|
}
|
|
|
|
if (symbol_conf.show_total_period) {
|
|
if (sep)
|
|
ret += scnprintf(s + ret, size - ret, "%c%" PRIu64, *sep, period);
|
|
else
|
|
ret += scnprintf(s + ret, size - ret, " %12" PRIu64, period);
|
|
}
|
|
|
|
if (pair_hists) {
|
|
char bf[32];
|
|
double old_percent = 0, new_percent = 0, diff;
|
|
|
|
if (total > 0)
|
|
old_percent = (period * 100.0) / total;
|
|
if (total_period > 0)
|
|
new_percent = (he->period * 100.0) / total_period;
|
|
|
|
diff = new_percent - old_percent;
|
|
|
|
if (fabs(diff) >= 0.01)
|
|
ret += scnprintf(bf, sizeof(bf), "%+4.2F%%", diff);
|
|
else
|
|
ret += scnprintf(bf, sizeof(bf), " ");
|
|
|
|
if (sep)
|
|
ret += scnprintf(s + ret, size - ret, "%c%s", *sep, bf);
|
|
else
|
|
ret += scnprintf(s + ret, size - ret, "%11.11s", bf);
|
|
|
|
if (show_displacement) {
|
|
if (displacement)
|
|
ret += scnprintf(bf, sizeof(bf), "%+4ld", displacement);
|
|
else
|
|
ret += scnprintf(bf, sizeof(bf), " ");
|
|
|
|
if (sep)
|
|
ret += scnprintf(s + ret, size - ret, "%c%s", *sep, bf);
|
|
else
|
|
ret += scnprintf(s + ret, size - ret, "%6.6s", bf);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int hist_entry__snprintf(struct hist_entry *he, char *s, size_t size,
|
|
struct hists *hists)
|
|
{
|
|
const char *sep = symbol_conf.field_sep;
|
|
struct sort_entry *se;
|
|
int ret = 0;
|
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
if (se->elide)
|
|
continue;
|
|
|
|
ret += scnprintf(s + ret, size - ret, "%s", sep ?: " ");
|
|
ret += se->se_snprintf(he, s + ret, size - ret,
|
|
hists__col_len(hists, se->se_width_idx));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int hist_entry__fprintf(struct hist_entry *he, size_t size,
|
|
struct hists *hists, struct hists *pair_hists,
|
|
bool show_displacement, long displacement,
|
|
u64 total_period, FILE *fp)
|
|
{
|
|
char bf[512];
|
|
int ret;
|
|
|
|
if (size == 0 || size > sizeof(bf))
|
|
size = sizeof(bf);
|
|
|
|
ret = hist_entry__pcnt_snprintf(he, bf, size, pair_hists,
|
|
show_displacement, displacement,
|
|
true, total_period);
|
|
hist_entry__snprintf(he, bf + ret, size - ret, hists);
|
|
return fprintf(fp, "%s\n", bf);
|
|
}
|
|
|
|
static size_t hist_entry__fprintf_callchain(struct hist_entry *he,
|
|
struct hists *hists,
|
|
u64 total_period, FILE *fp)
|
|
{
|
|
int left_margin = 0;
|
|
|
|
if (sort__first_dimension == SORT_COMM) {
|
|
struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
|
|
typeof(*se), list);
|
|
left_margin = hists__col_len(hists, se->se_width_idx);
|
|
left_margin -= thread__comm_len(he->thread);
|
|
}
|
|
|
|
return hist_entry_callchain__fprintf(he, total_period, left_margin, fp);
|
|
}
|
|
|
|
size_t hists__fprintf(struct hists *hists, struct hists *pair,
|
|
bool show_displacement, bool show_header, int max_rows,
|
|
int max_cols, FILE *fp)
|
|
{
|
|
struct sort_entry *se;
|
|
struct rb_node *nd;
|
|
size_t ret = 0;
|
|
u64 total_period;
|
|
unsigned long position = 1;
|
|
long displacement = 0;
|
|
unsigned int width;
|
|
const char *sep = symbol_conf.field_sep;
|
|
const char *col_width = symbol_conf.col_width_list_str;
|
|
int nr_rows = 0;
|
|
|
|
init_rem_hits();
|
|
|
|
if (!show_header)
|
|
goto print_entries;
|
|
|
|
fprintf(fp, "# %s", pair ? "Baseline" : "Overhead");
|
|
|
|
if (symbol_conf.show_cpu_utilization) {
|
|
if (sep) {
|
|
ret += fprintf(fp, "%csys", *sep);
|
|
ret += fprintf(fp, "%cus", *sep);
|
|
if (perf_guest) {
|
|
ret += fprintf(fp, "%cguest sys", *sep);
|
|
ret += fprintf(fp, "%cguest us", *sep);
|
|
}
|
|
} else {
|
|
ret += fprintf(fp, " sys ");
|
|
ret += fprintf(fp, " us ");
|
|
if (perf_guest) {
|
|
ret += fprintf(fp, " guest sys ");
|
|
ret += fprintf(fp, " guest us ");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (symbol_conf.show_nr_samples) {
|
|
if (sep)
|
|
fprintf(fp, "%cSamples", *sep);
|
|
else
|
|
fputs(" Samples ", fp);
|
|
}
|
|
|
|
if (symbol_conf.show_total_period) {
|
|
if (sep)
|
|
ret += fprintf(fp, "%cPeriod", *sep);
|
|
else
|
|
ret += fprintf(fp, " Period ");
|
|
}
|
|
|
|
if (pair) {
|
|
if (sep)
|
|
ret += fprintf(fp, "%cDelta", *sep);
|
|
else
|
|
ret += fprintf(fp, " Delta ");
|
|
|
|
if (show_displacement) {
|
|
if (sep)
|
|
ret += fprintf(fp, "%cDisplacement", *sep);
|
|
else
|
|
ret += fprintf(fp, " Displ");
|
|
}
|
|
}
|
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
if (se->elide)
|
|
continue;
|
|
if (sep) {
|
|
fprintf(fp, "%c%s", *sep, se->se_header);
|
|
continue;
|
|
}
|
|
width = strlen(se->se_header);
|
|
if (symbol_conf.col_width_list_str) {
|
|
if (col_width) {
|
|
hists__set_col_len(hists, se->se_width_idx,
|
|
atoi(col_width));
|
|
col_width = strchr(col_width, ',');
|
|
if (col_width)
|
|
++col_width;
|
|
}
|
|
}
|
|
if (!hists__new_col_len(hists, se->se_width_idx, width))
|
|
width = hists__col_len(hists, se->se_width_idx);
|
|
fprintf(fp, " %*s", width, se->se_header);
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
if (max_rows && ++nr_rows >= max_rows)
|
|
goto out;
|
|
|
|
if (sep)
|
|
goto print_entries;
|
|
|
|
fprintf(fp, "# ........");
|
|
if (symbol_conf.show_cpu_utilization)
|
|
fprintf(fp, " ....... .......");
|
|
if (symbol_conf.show_nr_samples)
|
|
fprintf(fp, " ..........");
|
|
if (symbol_conf.show_total_period)
|
|
fprintf(fp, " ............");
|
|
if (pair) {
|
|
fprintf(fp, " ..........");
|
|
if (show_displacement)
|
|
fprintf(fp, " .....");
|
|
}
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
unsigned int i;
|
|
|
|
if (se->elide)
|
|
continue;
|
|
|
|
fprintf(fp, " ");
|
|
width = hists__col_len(hists, se->se_width_idx);
|
|
if (width == 0)
|
|
width = strlen(se->se_header);
|
|
for (i = 0; i < width; i++)
|
|
fprintf(fp, ".");
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
if (max_rows && ++nr_rows >= max_rows)
|
|
goto out;
|
|
|
|
fprintf(fp, "#\n");
|
|
if (max_rows && ++nr_rows >= max_rows)
|
|
goto out;
|
|
|
|
print_entries:
|
|
total_period = hists->stats.total_period;
|
|
|
|
for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
|
|
struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
|
|
|
|
if (h->filtered)
|
|
continue;
|
|
|
|
if (show_displacement) {
|
|
if (h->pair != NULL)
|
|
displacement = ((long)h->pair->position -
|
|
(long)position);
|
|
else
|
|
displacement = 0;
|
|
++position;
|
|
}
|
|
ret += hist_entry__fprintf(h, max_cols, hists, pair, show_displacement,
|
|
displacement, total_period, fp);
|
|
|
|
if (symbol_conf.use_callchain)
|
|
ret += hist_entry__fprintf_callchain(h, hists, total_period, fp);
|
|
if (max_rows && ++nr_rows >= max_rows)
|
|
goto out;
|
|
|
|
if (h->ms.map == NULL && verbose > 1) {
|
|
__map_groups__fprintf_maps(&h->thread->mg,
|
|
MAP__FUNCTION, verbose, fp);
|
|
fprintf(fp, "%.10s end\n", graph_dotted_line);
|
|
}
|
|
}
|
|
out:
|
|
free(rem_sq_bracket);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* See hists__fprintf to match the column widths
|
|
*/
|
|
unsigned int hists__sort_list_width(struct hists *hists)
|
|
{
|
|
struct sort_entry *se;
|
|
int ret = 9; /* total % */
|
|
|
|
if (symbol_conf.show_cpu_utilization) {
|
|
ret += 7; /* count_sys % */
|
|
ret += 6; /* count_us % */
|
|
if (perf_guest) {
|
|
ret += 13; /* count_guest_sys % */
|
|
ret += 12; /* count_guest_us % */
|
|
}
|
|
}
|
|
|
|
if (symbol_conf.show_nr_samples)
|
|
ret += 11;
|
|
|
|
if (symbol_conf.show_total_period)
|
|
ret += 13;
|
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list)
|
|
if (!se->elide)
|
|
ret += 2 + hists__col_len(hists, se->se_width_idx);
|
|
|
|
if (verbose) /* Addr + origin */
|
|
ret += 3 + BITS_PER_LONG / 4;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h,
|
|
enum hist_filter filter)
|
|
{
|
|
h->filtered &= ~(1 << filter);
|
|
if (h->filtered)
|
|
return;
|
|
|
|
++hists->nr_entries;
|
|
if (h->ms.unfolded)
|
|
hists->nr_entries += h->nr_rows;
|
|
h->row_offset = 0;
|
|
hists->stats.total_period += h->period;
|
|
hists->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
|
|
|
|
hists__calc_col_len(hists, h);
|
|
}
|
|
|
|
|
|
static bool hists__filter_entry_by_dso(struct hists *hists,
|
|
struct hist_entry *he)
|
|
{
|
|
if (hists->dso_filter != NULL &&
|
|
(he->ms.map == NULL || he->ms.map->dso != hists->dso_filter)) {
|
|
he->filtered |= (1 << HIST_FILTER__DSO);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void hists__filter_by_dso(struct hists *hists)
|
|
{
|
|
struct rb_node *nd;
|
|
|
|
hists->nr_entries = hists->stats.total_period = 0;
|
|
hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
|
|
hists__reset_col_len(hists);
|
|
|
|
for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
|
|
struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
|
|
|
|
if (symbol_conf.exclude_other && !h->parent)
|
|
continue;
|
|
|
|
if (hists__filter_entry_by_dso(hists, h))
|
|
continue;
|
|
|
|
hists__remove_entry_filter(hists, h, HIST_FILTER__DSO);
|
|
}
|
|
}
|
|
|
|
static bool hists__filter_entry_by_thread(struct hists *hists,
|
|
struct hist_entry *he)
|
|
{
|
|
if (hists->thread_filter != NULL &&
|
|
he->thread != hists->thread_filter) {
|
|
he->filtered |= (1 << HIST_FILTER__THREAD);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void hists__filter_by_thread(struct hists *hists)
|
|
{
|
|
struct rb_node *nd;
|
|
|
|
hists->nr_entries = hists->stats.total_period = 0;
|
|
hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
|
|
hists__reset_col_len(hists);
|
|
|
|
for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
|
|
struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
|
|
|
|
if (hists__filter_entry_by_thread(hists, h))
|
|
continue;
|
|
|
|
hists__remove_entry_filter(hists, h, HIST_FILTER__THREAD);
|
|
}
|
|
}
|
|
|
|
int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip)
|
|
{
|
|
return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip);
|
|
}
|
|
|
|
int hist_entry__annotate(struct hist_entry *he, size_t privsize)
|
|
{
|
|
return symbol__annotate(he->ms.sym, he->ms.map, privsize);
|
|
}
|
|
|
|
void hists__inc_nr_events(struct hists *hists, u32 type)
|
|
{
|
|
++hists->stats.nr_events[0];
|
|
++hists->stats.nr_events[type];
|
|
}
|
|
|
|
size_t hists__fprintf_nr_events(struct hists *hists, FILE *fp)
|
|
{
|
|
int i;
|
|
size_t ret = 0;
|
|
|
|
for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
|
|
const char *name;
|
|
|
|
if (hists->stats.nr_events[i] == 0)
|
|
continue;
|
|
|
|
name = perf_event__name(i);
|
|
if (!strcmp(name, "UNKNOWN"))
|
|
continue;
|
|
|
|
ret += fprintf(fp, "%16s events: %10d\n", name,
|
|
hists->stats.nr_events[i]);
|
|
}
|
|
|
|
return ret;
|
|
}
|