2010-05-13 19:47:16 +02:00
|
|
|
#include "util.h"
|
2009-09-28 15:32:55 +02:00
|
|
|
#include "hist.h"
|
2009-12-14 16:10:39 +01:00
|
|
|
#include "session.h"
|
|
|
|
#include "sort.h"
|
2009-12-16 17:31:49 +01:00
|
|
|
#include <math.h>
|
2009-09-28 15:32:55 +02:00
|
|
|
|
|
|
|
struct callchain_param callchain_param = {
|
|
|
|
.mode = CHAIN_GRAPH_REL,
|
|
|
|
.min_percent = 0.5
|
|
|
|
};
|
|
|
|
|
2010-05-14 19:19:35 +02:00
|
|
|
static void hist_entry__add_cpumode_period(struct hist_entry *self,
|
|
|
|
unsigned int cpumode, u64 period)
|
2010-04-19 07:32:50 +02:00
|
|
|
{
|
2010-05-09 18:02:23 +02:00
|
|
|
switch (cpumode) {
|
2010-04-19 07:32:50 +02:00
|
|
|
case PERF_RECORD_MISC_KERNEL:
|
2010-05-14 19:19:35 +02:00
|
|
|
self->period_sys += period;
|
2010-04-19 07:32:50 +02:00
|
|
|
break;
|
|
|
|
case PERF_RECORD_MISC_USER:
|
2010-05-14 19:19:35 +02:00
|
|
|
self->period_us += period;
|
2010-04-19 07:32:50 +02:00
|
|
|
break;
|
|
|
|
case PERF_RECORD_MISC_GUEST_KERNEL:
|
2010-05-14 19:19:35 +02:00
|
|
|
self->period_guest_sys += period;
|
2010-04-19 07:32:50 +02:00
|
|
|
break;
|
|
|
|
case PERF_RECORD_MISC_GUEST_USER:
|
2010-05-14 19:19:35 +02:00
|
|
|
self->period_guest_us += period;
|
2010-04-19 07:32:50 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-28 15:32:55 +02:00
|
|
|
/*
|
2010-05-14 19:19:35 +02:00
|
|
|
* histogram, sorted on item, collects periods
|
2009-09-28 15:32:55 +02:00
|
|
|
*/
|
|
|
|
|
2010-05-09 18:02:23 +02:00
|
|
|
static struct hist_entry *hist_entry__new(struct hist_entry *template)
|
|
|
|
{
|
|
|
|
size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_node) : 0;
|
|
|
|
struct hist_entry *self = malloc(sizeof(*self) + callchain_size);
|
|
|
|
|
|
|
|
if (self != NULL) {
|
|
|
|
*self = *template;
|
2010-05-14 19:19:35 +02:00
|
|
|
self->nr_events = 1;
|
2010-05-09 18:02:23 +02:00
|
|
|
if (symbol_conf.use_callchain)
|
|
|
|
callchain_init(self->callchain);
|
|
|
|
}
|
|
|
|
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
2010-05-10 18:57:51 +02:00
|
|
|
static void hists__inc_nr_entries(struct hists *self, struct hist_entry *entry)
|
|
|
|
{
|
|
|
|
if (entry->ms.sym && self->max_sym_namelen < entry->ms.sym->namelen)
|
|
|
|
self->max_sym_namelen = entry->ms.sym->namelen;
|
|
|
|
++self->nr_entries;
|
|
|
|
}
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
struct hist_entry *__hists__add_entry(struct hists *self,
|
|
|
|
struct addr_location *al,
|
2010-05-14 19:19:35 +02:00
|
|
|
struct symbol *sym_parent, u64 period)
|
2009-10-03 15:42:45 +02:00
|
|
|
{
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
struct rb_node **p = &self->entries.rb_node;
|
2009-10-03 15:42:45 +02:00
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct hist_entry *he;
|
|
|
|
struct hist_entry entry = {
|
perf tools: Consolidate symbol resolving across all tools
Now we have a very high level routine for simple tools to
process IP sample events:
int event__preprocess_sample(const event_t *self,
struct addr_location *al,
symbol_filter_t filter)
It receives the event itself and will insert new threads in the
global threads list and resolve the map and symbol, filling all
this info into the new addr_location struct, so that tools like
annotate and report can further process the event by creating
hist_entries in their specific way (with or without callgraphs,
etc).
It in turn uses the new next layer function:
void thread__find_addr_location(struct thread *self, u8 cpumode,
enum map_type type, u64 addr,
struct addr_location *al,
symbol_filter_t filter)
This one will, given a thread (userspace or the kernel kthread
one), will find the given type (MAP__FUNCTION now, MAP__VARIABLE
too in the near future) at the given cpumode, taking vdsos into
account (userspace hit, but kernel symbol) and will fill all
these details in the addr_location given.
Tools that need a more compact API for plain function
resolution, like 'kmem', can use this other one:
struct symbol *thread__find_function(struct thread *self, u64 addr,
symbol_filter_t filter)
So, to resolve a kernel symbol, that is all the 'kmem' tool
needs, its just a matter of calling:
sym = thread__find_function(kthread, addr, NULL);
The 'filter' parameter is needed because we do lazy
parsing/loading of ELF symtabs or /proc/kallsyms.
With this we remove more code duplication all around, which is
always good, huh? :-)
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: John Kacur <jkacur@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1259346563-12568-12-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-27 19:29:23 +01:00
|
|
|
.thread = al->thread,
|
2010-03-24 20:40:17 +01:00
|
|
|
.ms = {
|
|
|
|
.map = al->map,
|
|
|
|
.sym = al->sym,
|
|
|
|
},
|
perf tools: Consolidate symbol resolving across all tools
Now we have a very high level routine for simple tools to
process IP sample events:
int event__preprocess_sample(const event_t *self,
struct addr_location *al,
symbol_filter_t filter)
It receives the event itself and will insert new threads in the
global threads list and resolve the map and symbol, filling all
this info into the new addr_location struct, so that tools like
annotate and report can further process the event by creating
hist_entries in their specific way (with or without callgraphs,
etc).
It in turn uses the new next layer function:
void thread__find_addr_location(struct thread *self, u8 cpumode,
enum map_type type, u64 addr,
struct addr_location *al,
symbol_filter_t filter)
This one will, given a thread (userspace or the kernel kthread
one), will find the given type (MAP__FUNCTION now, MAP__VARIABLE
too in the near future) at the given cpumode, taking vdsos into
account (userspace hit, but kernel symbol) and will fill all
these details in the addr_location given.
Tools that need a more compact API for plain function
resolution, like 'kmem', can use this other one:
struct symbol *thread__find_function(struct thread *self, u64 addr,
symbol_filter_t filter)
So, to resolve a kernel symbol, that is all the 'kmem' tool
needs, its just a matter of calling:
sym = thread__find_function(kthread, addr, NULL);
The 'filter' parameter is needed because we do lazy
parsing/loading of ELF symtabs or /proc/kallsyms.
With this we remove more code duplication all around, which is
always good, huh? :-)
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: John Kacur <jkacur@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1259346563-12568-12-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-27 19:29:23 +01:00
|
|
|
.ip = al->addr,
|
|
|
|
.level = al->level,
|
2010-05-14 19:19:35 +02:00
|
|
|
.period = period,
|
2009-10-03 15:42:45 +02:00
|
|
|
.parent = sym_parent,
|
|
|
|
};
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
while (*p != NULL) {
|
|
|
|
parent = *p;
|
|
|
|
he = rb_entry(parent, struct hist_entry, rb_node);
|
|
|
|
|
|
|
|
cmp = hist_entry__cmp(&entry, he);
|
|
|
|
|
|
|
|
if (!cmp) {
|
2010-05-14 19:19:35 +02:00
|
|
|
he->period += period;
|
|
|
|
++he->nr_events;
|
2010-05-09 18:02:23 +02:00
|
|
|
goto out;
|
2009-10-03 15:42:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cmp < 0)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
}
|
|
|
|
|
2010-05-09 18:02:23 +02:00
|
|
|
he = hist_entry__new(&entry);
|
2009-10-03 15:42:45 +02:00
|
|
|
if (!he)
|
|
|
|
return NULL;
|
|
|
|
rb_link_node(&he->rb_node, parent, p);
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
rb_insert_color(&he->rb_node, &self->entries);
|
2010-05-10 18:57:51 +02:00
|
|
|
hists__inc_nr_entries(self, he);
|
2010-05-09 18:02:23 +02:00
|
|
|
out:
|
2010-05-14 19:19:35 +02:00
|
|
|
hist_entry__add_cpumode_period(he, al->cpumode, period);
|
2009-10-03 15:42:45 +02:00
|
|
|
return he;
|
|
|
|
}
|
|
|
|
|
2009-09-28 15:32:55 +02:00
|
|
|
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) {
|
2010-04-14 19:11:29 +02:00
|
|
|
cmp = se->se_cmp(left, right);
|
2009-09-28 15:32:55 +02:00
|
|
|
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 *);
|
|
|
|
|
2010-04-14 19:11:29 +02:00
|
|
|
f = se->se_collapse ?: se->se_cmp;
|
2009-09-28 15:32:55 +02:00
|
|
|
|
|
|
|
cmp = f(left, right);
|
|
|
|
if (cmp)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void hist_entry__free(struct hist_entry *he)
|
|
|
|
{
|
|
|
|
free(he);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* collapse the histogram
|
|
|
|
*/
|
|
|
|
|
2010-05-10 18:57:51 +02:00
|
|
|
static bool collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
|
2009-09-28 15:32:55 +02:00
|
|
|
{
|
2009-12-14 14:37:11 +01:00
|
|
|
struct rb_node **p = &root->rb_node;
|
2009-09-28 15:32:55 +02:00
|
|
|
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);
|
|
|
|
|
|
|
|
cmp = hist_entry__collapse(iter, he);
|
|
|
|
|
|
|
|
if (!cmp) {
|
2010-05-14 19:19:35 +02:00
|
|
|
iter->period += he->period;
|
2009-09-28 15:32:55 +02:00
|
|
|
hist_entry__free(he);
|
2010-05-10 18:57:51 +02:00
|
|
|
return false;
|
2009-09-28 15:32:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cmp < 0)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&he->rb_node, parent, p);
|
2009-12-14 14:37:11 +01:00
|
|
|
rb_insert_color(&he->rb_node, root);
|
2010-05-10 18:57:51 +02:00
|
|
|
return true;
|
2009-09-28 15:32:55 +02:00
|
|
|
}
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
void hists__collapse_resort(struct hists *self)
|
2009-09-28 15:32:55 +02:00
|
|
|
{
|
2009-12-14 14:37:11 +01:00
|
|
|
struct rb_root tmp;
|
2009-09-28 15:32:55 +02:00
|
|
|
struct rb_node *next;
|
|
|
|
struct hist_entry *n;
|
|
|
|
|
|
|
|
if (!sort__need_collapse)
|
|
|
|
return;
|
|
|
|
|
2009-12-14 14:37:11 +01:00
|
|
|
tmp = RB_ROOT;
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
next = rb_first(&self->entries);
|
2010-05-10 18:57:51 +02:00
|
|
|
self->nr_entries = 0;
|
|
|
|
self->max_sym_namelen = 0;
|
2009-12-14 14:37:11 +01:00
|
|
|
|
2009-09-28 15:32:55 +02:00
|
|
|
while (next) {
|
|
|
|
n = rb_entry(next, struct hist_entry, rb_node);
|
|
|
|
next = rb_next(&n->rb_node);
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
rb_erase(&n->rb_node, &self->entries);
|
2010-05-10 18:57:51 +02:00
|
|
|
if (collapse__insert_entry(&tmp, n))
|
|
|
|
hists__inc_nr_entries(self, n);
|
2009-09-28 15:32:55 +02:00
|
|
|
}
|
2009-12-14 14:37:11 +01:00
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
self->entries = tmp;
|
2009-09-28 15:32:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-05-14 19:19:35 +02:00
|
|
|
* reverse the map, sort on period.
|
2009-09-28 15:32:55 +02:00
|
|
|
*/
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
static void __hists__insert_output_entry(struct rb_root *entries,
|
|
|
|
struct hist_entry *he,
|
|
|
|
u64 min_callchain_hits)
|
2009-09-28 15:32:55 +02:00
|
|
|
{
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
struct rb_node **p = &entries->rb_node;
|
2009-09-28 15:32:55 +02:00
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct hist_entry *iter;
|
|
|
|
|
2009-12-15 23:04:42 +01:00
|
|
|
if (symbol_conf.use_callchain)
|
2010-04-02 14:50:42 +02:00
|
|
|
callchain_param.sort(&he->sorted_chain, he->callchain,
|
2009-09-28 15:32:55 +02:00
|
|
|
min_callchain_hits, &callchain_param);
|
|
|
|
|
|
|
|
while (*p != NULL) {
|
|
|
|
parent = *p;
|
|
|
|
iter = rb_entry(parent, struct hist_entry, rb_node);
|
|
|
|
|
2010-05-14 19:19:35 +02:00
|
|
|
if (he->period > iter->period)
|
2009-09-28 15:32:55 +02:00
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&he->rb_node, parent, p);
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
rb_insert_color(&he->rb_node, entries);
|
2009-09-28 15:32:55 +02:00
|
|
|
}
|
|
|
|
|
2010-05-10 18:57:51 +02:00
|
|
|
void hists__output_resort(struct hists *self)
|
2009-09-28 15:32:55 +02:00
|
|
|
{
|
2009-12-14 14:37:11 +01:00
|
|
|
struct rb_root tmp;
|
2009-09-28 15:32:55 +02:00
|
|
|
struct rb_node *next;
|
|
|
|
struct hist_entry *n;
|
|
|
|
u64 min_callchain_hits;
|
|
|
|
|
2010-05-14 18:16:55 +02:00
|
|
|
min_callchain_hits = self->stats.total_period * (callchain_param.min_percent / 100);
|
2009-09-28 15:32:55 +02:00
|
|
|
|
2009-12-14 14:37:11 +01:00
|
|
|
tmp = RB_ROOT;
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
next = rb_first(&self->entries);
|
2009-09-28 15:32:55 +02:00
|
|
|
|
2010-05-10 18:57:51 +02:00
|
|
|
self->nr_entries = 0;
|
|
|
|
self->max_sym_namelen = 0;
|
|
|
|
|
2009-09-28 15:32:55 +02:00
|
|
|
while (next) {
|
|
|
|
n = rb_entry(next, struct hist_entry, rb_node);
|
|
|
|
next = rb_next(&n->rb_node);
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
rb_erase(&n->rb_node, &self->entries);
|
|
|
|
__hists__insert_output_entry(&tmp, n, min_callchain_hits);
|
2010-05-10 18:57:51 +02:00
|
|
|
hists__inc_nr_entries(self, n);
|
2009-09-28 15:32:55 +02:00
|
|
|
}
|
2009-12-14 14:37:11 +01:00
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
self->entries = tmp;
|
2009-09-28 15:32:55 +02:00
|
|
|
}
|
2009-12-16 15:27:09 +01:00
|
|
|
|
|
|
|
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,
|
2010-05-14 19:19:35 +02:00
|
|
|
int depth, int depth_mask, int period,
|
2009-12-16 15:27:09 +01:00
|
|
|
u64 total_samples, int 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, " ");
|
2010-05-14 19:19:35 +02:00
|
|
|
if (!period && i == depth - 1) {
|
2009-12-16 15:27:09 +01:00
|
|
|
double percent;
|
|
|
|
|
|
|
|
percent = hits * 100.0 / total_samples;
|
|
|
|
ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
|
|
|
|
} else
|
|
|
|
ret += fprintf(fp, "%s", " ");
|
|
|
|
}
|
2010-03-24 20:40:18 +01:00
|
|
|
if (chain->ms.sym)
|
|
|
|
ret += fprintf(fp, "%s\n", chain->ms.sym->name);
|
2009-12-16 15:27:09 +01:00
|
|
|
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, "[...]");
|
2010-03-24 20:40:18 +01:00
|
|
|
rem_hits.ms.sym = rem_sq_bracket;
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2010-05-10 01:28:10 +02:00
|
|
|
uint entries_printed = 0;
|
2009-12-16 15:27:09 +01:00
|
|
|
|
|
|
|
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 = 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));
|
|
|
|
|
|
|
|
/*
|
tree-wide: Assorted spelling fixes
In particular, several occurances of funny versions of 'success',
'unknown', 'therefore', 'acknowledge', 'argument', 'achieve', 'address',
'beginning', 'desirable', 'separate' and 'necessary' are fixed.
Signed-off-by: Daniel Mack <daniel@caiaq.de>
Cc: Joe Perches <joe@perches.com>
Cc: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2010-02-03 01:01:28 +01:00
|
|
|
* But we keep the older depth mask for the line separator
|
2009-12-16 15:27:09 +01:00
|
|
|
* 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;
|
2010-05-10 01:28:10 +02:00
|
|
|
if (++entries_printed == callchain_param.print_limit)
|
|
|
|
break;
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2010-05-10 01:28:10 +02:00
|
|
|
u32 entries_printed = 0;
|
2009-12-16 15:27:09 +01:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2010-03-24 20:40:18 +01:00
|
|
|
if (chain->ms.sym)
|
|
|
|
ret += fprintf(fp, " %s\n", chain->ms.sym->name);
|
2009-12-16 15:27:09 +01:00
|
|
|
else
|
|
|
|
ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
|
2010-05-10 01:28:10 +02:00
|
|
|
|
|
|
|
if (++entries_printed == callchain_param.print_limit)
|
|
|
|
break;
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2010-03-24 20:40:18 +01:00
|
|
|
if (chain->ms.sym)
|
|
|
|
ret += fprintf(fp, " %s\n", chain->ms.sym->name);
|
2009-12-16 15:27:09 +01:00
|
|
|
else
|
|
|
|
ret += fprintf(fp, " %p\n",
|
|
|
|
(void *)(long)chain->ip);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
|
|
|
|
u64 total_samples, int left_margin)
|
|
|
|
{
|
|
|
|
struct rb_node *rb_node;
|
|
|
|
struct callchain_node *chain;
|
|
|
|
size_t ret = 0;
|
2010-05-10 01:28:10 +02:00
|
|
|
u32 entries_printed = 0;
|
2009-12-16 15:27:09 +01:00
|
|
|
|
|
|
|
rb_node = rb_first(&self->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");
|
2010-05-10 01:28:10 +02:00
|
|
|
if (++entries_printed == callchain_param.print_limit)
|
|
|
|
break;
|
2009-12-16 15:27:09 +01:00
|
|
|
rb_node = rb_next(rb_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
|
|
|
|
struct hists *pair_hists, bool show_displacement,
|
|
|
|
long displacement, bool color, u64 session_total)
|
2009-12-16 15:27:09 +01:00
|
|
|
{
|
|
|
|
struct sort_entry *se;
|
2010-05-14 19:19:35 +02:00
|
|
|
u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
const char *sep = symbol_conf.field_sep;
|
2010-03-31 16:33:40 +02:00
|
|
|
int ret;
|
2009-12-16 15:27:09 +01:00
|
|
|
|
|
|
|
if (symbol_conf.exclude_other && !self->parent)
|
|
|
|
return 0;
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
if (pair_hists) {
|
2010-05-14 19:19:35 +02:00
|
|
|
period = self->pair ? self->pair->period : 0;
|
2010-05-14 18:16:55 +02:00
|
|
|
total = pair_hists->stats.total_period;
|
2010-05-14 19:19:35 +02:00
|
|
|
period_sys = self->pair ? self->pair->period_sys : 0;
|
|
|
|
period_us = self->pair ? self->pair->period_us : 0;
|
|
|
|
period_guest_sys = self->pair ? self->pair->period_guest_sys : 0;
|
|
|
|
period_guest_us = self->pair ? self->pair->period_guest_us : 0;
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
} else {
|
2010-05-14 19:19:35 +02:00
|
|
|
period = self->period;
|
2010-03-05 16:51:08 +01:00
|
|
|
total = session_total;
|
2010-05-14 19:19:35 +02:00
|
|
|
period_sys = self->period_sys;
|
|
|
|
period_us = self->period_us;
|
|
|
|
period_guest_sys = self->period_guest_sys;
|
|
|
|
period_guest_us = self->period_guest_us;
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
}
|
|
|
|
|
2010-03-31 16:33:40 +02:00
|
|
|
if (total) {
|
|
|
|
if (color)
|
|
|
|
ret = percent_color_snprintf(s, size,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 19:19:35 +02:00
|
|
|
(period * 100.0) / total);
|
2010-03-31 16:33:40 +02:00
|
|
|
else
|
|
|
|
ret = snprintf(s, size, sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 19:19:35 +02:00
|
|
|
(period * 100.0) / total);
|
2010-04-19 07:32:50 +02:00
|
|
|
if (symbol_conf.show_cpu_utilization) {
|
|
|
|
ret += percent_color_snprintf(s + ret, size - ret,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 19:19:35 +02:00
|
|
|
(period_sys * 100.0) / total);
|
2010-04-19 07:32:50 +02:00
|
|
|
ret += percent_color_snprintf(s + ret, size - ret,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 19:19:35 +02:00
|
|
|
(period_us * 100.0) / total);
|
2010-04-19 07:32:50 +02:00
|
|
|
if (perf_guest) {
|
|
|
|
ret += percent_color_snprintf(s + ret,
|
|
|
|
size - ret,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 19:19:35 +02:00
|
|
|
(period_guest_sys * 100.0) /
|
2010-04-19 07:32:50 +02:00
|
|
|
total);
|
|
|
|
ret += percent_color_snprintf(s + ret,
|
|
|
|
size - ret,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 19:19:35 +02:00
|
|
|
(period_guest_us * 100.0) /
|
2010-04-19 07:32:50 +02:00
|
|
|
total);
|
|
|
|
}
|
|
|
|
}
|
2010-03-31 16:33:40 +02:00
|
|
|
} else
|
2010-05-14 19:19:35 +02:00
|
|
|
ret = snprintf(s, size, sep ? "%lld" : "%12lld ", period);
|
2009-12-16 15:27:09 +01:00
|
|
|
|
|
|
|
if (symbol_conf.show_nr_samples) {
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
if (sep)
|
2010-05-14 19:19:35 +02:00
|
|
|
ret += snprintf(s + ret, size - ret, "%c%lld", *sep, period);
|
2009-12-16 15:27:09 +01:00
|
|
|
else
|
2010-05-14 19:19:35 +02:00
|
|
|
ret += snprintf(s + ret, size - ret, "%11lld", period);
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
}
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
if (pair_hists) {
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
char bf[32];
|
|
|
|
double old_percent = 0, new_percent = 0, diff;
|
|
|
|
|
|
|
|
if (total > 0)
|
2010-05-14 19:19:35 +02:00
|
|
|
old_percent = (period * 100.0) / total;
|
2010-03-05 16:51:08 +01:00
|
|
|
if (session_total > 0)
|
2010-05-14 19:19:35 +02:00
|
|
|
new_percent = (self->period * 100.0) / session_total;
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
|
2009-12-16 17:31:49 +01:00
|
|
|
diff = new_percent - old_percent;
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
|
2009-12-16 17:31:49 +01:00
|
|
|
if (fabs(diff) >= 0.01)
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
snprintf(bf, sizeof(bf), "%+4.2F%%", diff);
|
|
|
|
else
|
|
|
|
snprintf(bf, sizeof(bf), " ");
|
|
|
|
|
|
|
|
if (sep)
|
2010-03-31 16:33:40 +02:00
|
|
|
ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
else
|
2010-03-31 16:33:40 +02:00
|
|
|
ret += snprintf(s + ret, size - ret, "%11.11s", bf);
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
|
|
|
|
if (show_displacement) {
|
|
|
|
if (displacement)
|
|
|
|
snprintf(bf, sizeof(bf), "%+4ld", displacement);
|
|
|
|
else
|
|
|
|
snprintf(bf, sizeof(bf), " ");
|
|
|
|
|
|
|
|
if (sep)
|
2010-03-31 16:33:40 +02:00
|
|
|
ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
else
|
2010-03-31 16:33:40 +02:00
|
|
|
ret += snprintf(s + ret, size - ret, "%6.6s", bf);
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
}
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
|
|
if (se->elide)
|
|
|
|
continue;
|
|
|
|
|
2010-03-31 16:33:40 +02:00
|
|
|
ret += snprintf(s + ret, size - ret, "%s", sep ?: " ");
|
2010-04-14 19:11:29 +02:00
|
|
|
ret += se->se_snprintf(self, s + ret, size - ret,
|
|
|
|
se->se_width ? *se->se_width : 0);
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
|
|
|
|
2010-03-31 16:33:40 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
int hist_entry__fprintf(struct hist_entry *self, struct hists *pair_hists,
|
|
|
|
bool show_displacement, long displacement, FILE *fp,
|
2010-03-31 16:33:40 +02:00
|
|
|
u64 session_total)
|
|
|
|
{
|
|
|
|
char bf[512];
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
hist_entry__snprintf(self, bf, sizeof(bf), pair_hists,
|
2010-03-31 16:33:40 +02:00
|
|
|
show_displacement, displacement,
|
|
|
|
true, session_total);
|
|
|
|
return fprintf(fp, "%s\n", bf);
|
2010-03-12 16:46:48 +01:00
|
|
|
}
|
2009-12-16 15:27:09 +01:00
|
|
|
|
2010-03-12 16:46:48 +01:00
|
|
|
static size_t hist_entry__fprintf_callchain(struct hist_entry *self, FILE *fp,
|
|
|
|
u64 session_total)
|
|
|
|
{
|
|
|
|
int left_margin = 0;
|
2009-12-16 15:27:09 +01:00
|
|
|
|
2010-03-12 16:46:48 +01:00
|
|
|
if (sort__first_dimension == SORT_COMM) {
|
|
|
|
struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
|
|
|
|
typeof(*se), list);
|
2010-04-14 19:11:29 +02:00
|
|
|
left_margin = se->se_width ? *se->se_width : 0;
|
2010-03-12 16:46:48 +01:00
|
|
|
left_margin -= thread__comm_len(self->thread);
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
|
|
|
|
2010-03-12 16:46:48 +01:00
|
|
|
return hist_entry_callchain__fprintf(fp, self, session_total,
|
|
|
|
left_margin);
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
|
|
|
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
size_t hists__fprintf(struct hists *self, struct hists *pair,
|
|
|
|
bool show_displacement, FILE *fp)
|
2009-12-16 15:27:09 +01:00
|
|
|
{
|
|
|
|
struct sort_entry *se;
|
|
|
|
struct rb_node *nd;
|
|
|
|
size_t ret = 0;
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
unsigned long position = 1;
|
|
|
|
long displacement = 0;
|
2009-12-16 15:27:09 +01:00
|
|
|
unsigned int width;
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
const char *sep = symbol_conf.field_sep;
|
2009-12-16 15:27:09 +01:00
|
|
|
char *col_width = symbol_conf.col_width_list_str;
|
|
|
|
|
|
|
|
init_rem_hits();
|
|
|
|
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
fprintf(fp, "# %s", pair ? "Baseline" : "Overhead");
|
|
|
|
|
2009-12-16 15:27:09 +01:00
|
|
|
if (symbol_conf.show_nr_samples) {
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
if (sep)
|
|
|
|
fprintf(fp, "%cSamples", *sep);
|
2009-12-16 15:27:09 +01:00
|
|
|
else
|
|
|
|
fputs(" Samples ", fp);
|
|
|
|
}
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
|
2010-04-19 07:32:50 +02:00
|
|
|
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 ");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
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");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-16 15:27:09 +01:00
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
|
|
if (se->elide)
|
|
|
|
continue;
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
if (sep) {
|
2010-04-14 19:11:29 +02:00
|
|
|
fprintf(fp, "%c%s", *sep, se->se_header);
|
2009-12-16 15:27:09 +01:00
|
|
|
continue;
|
|
|
|
}
|
2010-04-14 19:11:29 +02:00
|
|
|
width = strlen(se->se_header);
|
|
|
|
if (se->se_width) {
|
2009-12-16 15:27:09 +01:00
|
|
|
if (symbol_conf.col_width_list_str) {
|
|
|
|
if (col_width) {
|
2010-04-14 19:11:29 +02:00
|
|
|
*se->se_width = atoi(col_width);
|
2009-12-16 15:27:09 +01:00
|
|
|
col_width = strchr(col_width, ',');
|
|
|
|
if (col_width)
|
|
|
|
++col_width;
|
|
|
|
}
|
|
|
|
}
|
2010-04-14 19:11:29 +02:00
|
|
|
width = *se->se_width = max(*se->se_width, width);
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
2010-04-14 19:11:29 +02:00
|
|
|
fprintf(fp, " %*s", width, se->se_header);
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
if (sep)
|
2009-12-16 15:27:09 +01:00
|
|
|
goto print_entries;
|
|
|
|
|
|
|
|
fprintf(fp, "# ........");
|
|
|
|
if (symbol_conf.show_nr_samples)
|
|
|
|
fprintf(fp, " ..........");
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
if (pair) {
|
|
|
|
fprintf(fp, " ..........");
|
|
|
|
if (show_displacement)
|
|
|
|
fprintf(fp, " .....");
|
|
|
|
}
|
2009-12-16 15:27:09 +01:00
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
if (se->elide)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
fprintf(fp, " ");
|
2010-04-14 19:11:29 +02:00
|
|
|
if (se->se_width)
|
|
|
|
width = *se->se_width;
|
2009-12-16 15:27:09 +01:00
|
|
|
else
|
2010-04-14 19:11:29 +02:00
|
|
|
width = strlen(se->se_header);
|
2009-12-16 15:27:09 +01:00
|
|
|
for (i = 0; i < width; i++)
|
|
|
|
fprintf(fp, ".");
|
|
|
|
}
|
|
|
|
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
fprintf(fp, "\n#\n");
|
2009-12-16 15:27:09 +01:00
|
|
|
|
|
|
|
print_entries:
|
perf hist: Introduce hists class and move lots of methods to it
In cbbc79a we introduced support for multiple events by introducing a
new "event_stat_id" struct and then made several perf_session methods
receive a point to it instead of a pointer to perf_session, and kept the
event_stats and hists rb_tree in perf_session.
While working on the new newt based browser, I realised that it would be
better to introduce a new class, "hists" (short for "histograms"),
renaming the "event_stat_id" struct and the perf_session methods that
were really "hists" methods, as they manipulate only struct hists
members, not touching anything in the other perf_session members.
Other optimizations, such as calculating the maximum lenght of a symbol
name present in an hists instance will be possible as we add them,
avoiding a re-traversal just for finding that information.
The rationale for the name "hists" to replace "event_stat_id" is that we
may have multiple sets of hists for the same event_stat id, as, for
instance, the 'perf diff' tool has, so event stat id is not what
characterizes what this struct and the functions that manipulate it do.
Cc: Eric B Munson <ebmunson@us.ibm.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Tom Zanussi <tzanussi@gmail.com>
LKML-Reference: <new-submission>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2010-05-10 18:04:11 +02:00
|
|
|
for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 16:49:27 +01:00
|
|
|
struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
|
|
|
|
|
|
|
|
if (show_displacement) {
|
|
|
|
if (h->pair != NULL)
|
|
|
|
displacement = ((long)h->pair->position -
|
|
|
|
(long)position);
|
|
|
|
else
|
|
|
|
displacement = 0;
|
|
|
|
++position;
|
|
|
|
}
|
2010-03-05 16:51:08 +01:00
|
|
|
ret += hist_entry__fprintf(h, pair, show_displacement,
|
2010-05-14 18:16:55 +02:00
|
|
|
displacement, fp, self->stats.total_period);
|
2010-03-12 16:46:48 +01:00
|
|
|
|
|
|
|
if (symbol_conf.use_callchain)
|
2010-05-14 18:16:55 +02:00
|
|
|
ret += hist_entry__fprintf_callchain(h, fp, self->stats.total_period);
|
2010-03-12 16:46:48 +01:00
|
|
|
|
2010-03-24 20:40:17 +01:00
|
|
|
if (h->ms.map == NULL && verbose > 1) {
|
2010-03-09 19:58:17 +01:00
|
|
|
__map_groups__fprintf_maps(&h->thread->mg,
|
2010-03-26 16:11:06 +01:00
|
|
|
MAP__FUNCTION, verbose, fp);
|
2010-03-09 19:58:17 +01:00
|
|
|
fprintf(fp, "%.10s end\n", graph_dotted_line);
|
|
|
|
}
|
2009-12-16 15:27:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
free(rem_sq_bracket);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2010-05-11 16:10:15 +02:00
|
|
|
|
|
|
|
enum hist_filter {
|
|
|
|
HIST_FILTER__DSO,
|
|
|
|
HIST_FILTER__THREAD,
|
|
|
|
};
|
|
|
|
|
|
|
|
void hists__filter_by_dso(struct hists *self, const struct dso *dso)
|
|
|
|
{
|
|
|
|
struct rb_node *nd;
|
|
|
|
|
2010-05-14 18:16:55 +02:00
|
|
|
self->nr_entries = self->stats.total_period = 0;
|
2010-05-14 19:19:35 +02:00
|
|
|
self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
|
2010-05-11 16:10:15 +02:00
|
|
|
self->max_sym_namelen = 0;
|
|
|
|
|
|
|
|
for (nd = rb_first(&self->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 (dso != NULL && (h->ms.map == NULL || h->ms.map->dso != dso)) {
|
|
|
|
h->filtered |= (1 << HIST_FILTER__DSO);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
h->filtered &= ~(1 << HIST_FILTER__DSO);
|
|
|
|
if (!h->filtered) {
|
|
|
|
++self->nr_entries;
|
2010-05-14 19:19:35 +02:00
|
|
|
self->stats.total_period += h->period;
|
|
|
|
self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
|
2010-05-11 16:10:15 +02:00
|
|
|
if (h->ms.sym &&
|
|
|
|
self->max_sym_namelen < h->ms.sym->namelen)
|
|
|
|
self->max_sym_namelen = h->ms.sym->namelen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void hists__filter_by_thread(struct hists *self, const struct thread *thread)
|
|
|
|
{
|
|
|
|
struct rb_node *nd;
|
|
|
|
|
2010-05-14 18:16:55 +02:00
|
|
|
self->nr_entries = self->stats.total_period = 0;
|
2010-05-14 19:19:35 +02:00
|
|
|
self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
|
2010-05-11 16:10:15 +02:00
|
|
|
self->max_sym_namelen = 0;
|
|
|
|
|
|
|
|
for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
|
|
|
|
struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
|
|
|
|
|
|
|
|
if (thread != NULL && h->thread != thread) {
|
|
|
|
h->filtered |= (1 << HIST_FILTER__THREAD);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
h->filtered &= ~(1 << HIST_FILTER__THREAD);
|
|
|
|
if (!h->filtered) {
|
|
|
|
++self->nr_entries;
|
2010-05-14 19:19:35 +02:00
|
|
|
self->stats.total_period += h->period;
|
|
|
|
self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
|
2010-05-11 16:10:15 +02:00
|
|
|
if (h->ms.sym &&
|
|
|
|
self->max_sym_namelen < h->ms.sym->namelen)
|
|
|
|
self->max_sym_namelen = h->ms.sym->namelen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-05-12 04:18:06 +02:00
|
|
|
|
|
|
|
static int symbol__alloc_hist(struct symbol *self)
|
|
|
|
{
|
|
|
|
struct sym_priv *priv = symbol__priv(self);
|
|
|
|
const int size = (sizeof(*priv->hist) +
|
|
|
|
(self->end - self->start) * sizeof(u64));
|
|
|
|
|
|
|
|
priv->hist = zalloc(size);
|
|
|
|
return priv->hist == NULL ? -1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int hist_entry__inc_addr_samples(struct hist_entry *self, u64 ip)
|
|
|
|
{
|
|
|
|
unsigned int sym_size, offset;
|
|
|
|
struct symbol *sym = self->ms.sym;
|
|
|
|
struct sym_priv *priv;
|
|
|
|
struct sym_hist *h;
|
|
|
|
|
|
|
|
if (!sym || !self->ms.map)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
priv = symbol__priv(sym);
|
|
|
|
if (priv->hist == NULL && symbol__alloc_hist(sym) < 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
sym_size = sym->end - sym->start;
|
|
|
|
offset = ip - sym->start;
|
|
|
|
|
|
|
|
pr_debug3("%s: ip=%#Lx\n", __func__, self->ms.map->unmap_ip(self->ms.map, ip));
|
|
|
|
|
|
|
|
if (offset >= sym_size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
h = priv->hist;
|
|
|
|
h->sum++;
|
|
|
|
h->ip[offset]++;
|
|
|
|
|
2010-05-14 19:19:35 +02:00
|
|
|
pr_debug3("%#Lx %s: period++ [ip: %#Lx, %#Lx] => %Ld\n", self->ms.sym->start,
|
2010-05-12 04:18:06 +02:00
|
|
|
self->ms.sym->name, ip, ip - self->ms.sym->start, h->ip[offset]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct objdump_line *objdump_line__new(s64 offset, char *line)
|
|
|
|
{
|
|
|
|
struct objdump_line *self = malloc(sizeof(*self));
|
|
|
|
|
|
|
|
if (self != NULL) {
|
|
|
|
self->offset = offset;
|
|
|
|
self->line = line;
|
|
|
|
}
|
|
|
|
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
void objdump_line__free(struct objdump_line *self)
|
|
|
|
{
|
|
|
|
free(self->line);
|
|
|
|
free(self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void objdump__add_line(struct list_head *head, struct objdump_line *line)
|
|
|
|
{
|
|
|
|
list_add_tail(&line->node, head);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
|
|
|
|
struct objdump_line *pos)
|
|
|
|
{
|
|
|
|
list_for_each_entry_continue(pos, head, node)
|
|
|
|
if (pos->offset >= 0)
|
|
|
|
return pos;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hist_entry__parse_objdump_line(struct hist_entry *self, FILE *file,
|
|
|
|
struct list_head *head)
|
|
|
|
{
|
|
|
|
struct symbol *sym = self->ms.sym;
|
|
|
|
struct objdump_line *objdump_line;
|
|
|
|
char *line = NULL, *tmp, *tmp2, *c;
|
|
|
|
size_t line_len;
|
|
|
|
s64 line_ip, offset = -1;
|
|
|
|
|
|
|
|
if (getline(&line, &line_len, file) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (!line)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
while (line_len != 0 && isspace(line[line_len - 1]))
|
|
|
|
line[--line_len] = '\0';
|
|
|
|
|
|
|
|
c = strchr(line, '\n');
|
|
|
|
if (c)
|
|
|
|
*c = 0;
|
|
|
|
|
|
|
|
line_ip = -1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Strip leading spaces:
|
|
|
|
*/
|
|
|
|
tmp = line;
|
|
|
|
while (*tmp) {
|
|
|
|
if (*tmp != ' ')
|
|
|
|
break;
|
|
|
|
tmp++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*tmp) {
|
|
|
|
/*
|
|
|
|
* Parse hexa addresses followed by ':'
|
|
|
|
*/
|
|
|
|
line_ip = strtoull(tmp, &tmp2, 16);
|
|
|
|
if (*tmp2 != ':')
|
|
|
|
line_ip = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (line_ip != -1) {
|
|
|
|
u64 start = map__rip_2objdump(self->ms.map, sym->start);
|
|
|
|
offset = line_ip - start;
|
|
|
|
}
|
|
|
|
|
|
|
|
objdump_line = objdump_line__new(offset, line);
|
|
|
|
if (objdump_line == NULL) {
|
|
|
|
free(line);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
objdump__add_line(head, objdump_line);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int hist_entry__annotate(struct hist_entry *self, struct list_head *head)
|
|
|
|
{
|
|
|
|
struct symbol *sym = self->ms.sym;
|
|
|
|
struct map *map = self->ms.map;
|
|
|
|
struct dso *dso = map->dso;
|
|
|
|
const char *filename = dso->long_name;
|
|
|
|
char command[PATH_MAX * 2];
|
|
|
|
FILE *file;
|
|
|
|
u64 len;
|
|
|
|
|
|
|
|
if (!filename)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (dso->origin == DSO__ORIG_KERNEL) {
|
|
|
|
if (dso->annotate_warned)
|
|
|
|
return 0;
|
|
|
|
dso->annotate_warned = 1;
|
|
|
|
pr_err("Can't annotate %s: No vmlinux file was found in the "
|
|
|
|
"path:\n", sym->name);
|
|
|
|
vmlinux_path__fprintf(stderr);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
pr_debug("%s: filename=%s, sym=%s, start=%#Lx, end=%#Lx\n", __func__,
|
|
|
|
filename, sym->name, map->unmap_ip(map, sym->start),
|
|
|
|
map->unmap_ip(map, sym->end));
|
|
|
|
|
|
|
|
len = sym->end - sym->start;
|
|
|
|
|
|
|
|
pr_debug("annotating [%p] %30s : [%p] %30s\n",
|
|
|
|
dso, dso->long_name, sym, sym->name);
|
|
|
|
|
|
|
|
snprintf(command, sizeof(command),
|
|
|
|
"objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s|expand",
|
|
|
|
map__rip_2objdump(map, sym->start),
|
|
|
|
map__rip_2objdump(map, sym->end),
|
|
|
|
filename, filename);
|
|
|
|
|
|
|
|
pr_debug("Executing: %s\n", command);
|
|
|
|
|
|
|
|
file = popen(command, "r");
|
|
|
|
if (!file)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
while (!feof(file))
|
|
|
|
if (hist_entry__parse_objdump_line(self, file, head) < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
pclose(file);
|
|
|
|
return 0;
|
|
|
|
}
|
2010-05-14 15:36:42 +02:00
|
|
|
|
|
|
|
void hists__inc_nr_events(struct hists *self, u32 type)
|
|
|
|
{
|
2010-05-14 18:16:55 +02:00
|
|
|
++self->stats.nr_events[0];
|
|
|
|
++self->stats.nr_events[type];
|
2010-05-14 15:36:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t hists__fprintf_nr_events(struct hists *self, FILE *fp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
size_t ret = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
|
|
|
|
if (!event__name[i])
|
|
|
|
continue;
|
|
|
|
ret += fprintf(fp, "%10s events: %10d\n",
|
|
|
|
event__name[i], self->stats.nr_events[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|