2011-02-04 11:45:46 +00:00
|
|
|
#include "annotate.h"
|
2010-05-13 17:47:16 +00:00
|
|
|
#include "util.h"
|
2010-05-21 10:48:39 +00:00
|
|
|
#include "build-id.h"
|
2009-09-28 13:32:55 +00:00
|
|
|
#include "hist.h"
|
2009-12-14 15:10:39 +00:00
|
|
|
#include "session.h"
|
|
|
|
#include "sort.h"
|
2009-12-16 16:31:49 +00:00
|
|
|
#include <math.h>
|
2009-09-28 13:32:55 +00:00
|
|
|
|
2011-10-19 15:09:10 +00:00
|
|
|
static bool hists__filter_entry_by_dso(struct hists *hists,
|
|
|
|
struct hist_entry *he);
|
|
|
|
static bool hists__filter_entry_by_thread(struct hists *hists,
|
|
|
|
struct hist_entry *he);
|
2012-03-16 08:50:51 +00:00
|
|
|
static bool hists__filter_entry_by_symbol(struct hists *hists,
|
|
|
|
struct hist_entry *he);
|
2011-10-19 15:09:10 +00:00
|
|
|
|
2010-07-21 12:19:41 +00:00
|
|
|
enum hist_filter {
|
|
|
|
HIST_FILTER__DSO,
|
|
|
|
HIST_FILTER__THREAD,
|
|
|
|
HIST_FILTER__PARENT,
|
2012-03-16 08:50:51 +00:00
|
|
|
HIST_FILTER__SYMBOL,
|
2010-07-21 12:19:41 +00:00
|
|
|
};
|
|
|
|
|
2009-09-28 13:32:55 +00:00
|
|
|
struct callchain_param callchain_param = {
|
|
|
|
.mode = CHAIN_GRAPH_REL,
|
2011-06-07 15:49:46 +00:00
|
|
|
.min_percent = 0.5,
|
|
|
|
.order = ORDER_CALLEE
|
2009-09-28 13:32:55 +00:00
|
|
|
};
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
u16 hists__col_len(struct hists *hists, enum hist_column col)
|
2010-07-20 17:42:52 +00:00
|
|
|
{
|
2011-09-26 15:33:28 +00:00
|
|
|
return hists->col_len[col];
|
2010-07-20 17:42:52 +00:00
|
|
|
}
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
void hists__set_col_len(struct hists *hists, enum hist_column col, u16 len)
|
2010-07-20 17:42:52 +00:00
|
|
|
{
|
2011-09-26 15:33:28 +00:00
|
|
|
hists->col_len[col] = len;
|
2010-07-20 17:42:52 +00:00
|
|
|
}
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
bool hists__new_col_len(struct hists *hists, enum hist_column col, u16 len)
|
2010-07-20 17:42:52 +00:00
|
|
|
{
|
2011-09-26 15:33:28 +00:00
|
|
|
if (len > hists__col_len(hists, col)) {
|
|
|
|
hists__set_col_len(hists, col, len);
|
2010-07-20 17:42:52 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
static void hists__reset_col_len(struct hists *hists)
|
2010-07-20 17:42:52 +00:00
|
|
|
{
|
|
|
|
enum hist_column col;
|
|
|
|
|
|
|
|
for (col = 0; col < HISTC_NR_COLS; ++col)
|
2011-09-26 15:33:28 +00:00
|
|
|
hists__set_col_len(hists, col, 0);
|
2010-07-20 17:42:52 +00:00
|
|
|
}
|
|
|
|
|
2012-02-09 22:21:01 +00:00
|
|
|
static void hists__set_unres_dso_col_len(struct hists *hists, int dso)
|
|
|
|
{
|
|
|
|
const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
|
|
|
|
|
|
|
|
if (hists__col_len(hists, dso) < unresolved_col_width &&
|
|
|
|
!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
|
|
|
|
!symbol_conf.dso_list)
|
|
|
|
hists__set_col_len(hists, dso, unresolved_col_width);
|
|
|
|
}
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
|
2010-07-20 17:42:52 +00:00
|
|
|
{
|
2012-02-09 22:21:01 +00:00
|
|
|
const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
|
2010-07-20 17:42:52 +00:00
|
|
|
u16 len;
|
|
|
|
|
|
|
|
if (h->ms.sym)
|
2012-02-09 22:21:01 +00:00
|
|
|
hists__new_col_len(hists, HISTC_SYMBOL, h->ms.sym->namelen + 4);
|
|
|
|
else
|
|
|
|
hists__set_unres_dso_col_len(hists, HISTC_DSO);
|
2010-07-20 17:42:52 +00:00
|
|
|
|
|
|
|
len = thread__comm_len(h->thread);
|
2011-09-26 15:33:28 +00:00
|
|
|
if (hists__new_col_len(hists, HISTC_COMM, len))
|
|
|
|
hists__set_col_len(hists, HISTC_THREAD, len + 6);
|
2010-07-20 17:42:52 +00:00
|
|
|
|
|
|
|
if (h->ms.map) {
|
|
|
|
len = dso__name_len(h->ms.map->dso);
|
2011-09-26 15:33:28 +00:00
|
|
|
hists__new_col_len(hists, HISTC_DSO, len);
|
2010-07-20 17:42:52 +00:00
|
|
|
}
|
2012-02-09 22:21:01 +00:00
|
|
|
|
|
|
|
if (h->branch_info) {
|
|
|
|
int symlen;
|
|
|
|
/*
|
|
|
|
* +4 accounts for '[x] ' priv level info
|
|
|
|
* +2 account of 0x prefix on raw addresses
|
|
|
|
*/
|
|
|
|
if (h->branch_info->from.sym) {
|
|
|
|
symlen = (int)h->branch_info->from.sym->namelen + 4;
|
|
|
|
hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
|
|
|
|
|
|
|
|
symlen = dso__name_len(h->branch_info->from.map->dso);
|
|
|
|
hists__new_col_len(hists, HISTC_DSO_FROM, symlen);
|
|
|
|
} else {
|
|
|
|
symlen = unresolved_col_width + 4 + 2;
|
|
|
|
hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
|
|
|
|
hists__set_unres_dso_col_len(hists, HISTC_DSO_FROM);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (h->branch_info->to.sym) {
|
|
|
|
symlen = (int)h->branch_info->to.sym->namelen + 4;
|
|
|
|
hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
|
|
|
|
|
|
|
|
symlen = dso__name_len(h->branch_info->to.map->dso);
|
|
|
|
hists__new_col_len(hists, HISTC_DSO_TO, symlen);
|
|
|
|
} else {
|
|
|
|
symlen = unresolved_col_width + 4 + 2;
|
|
|
|
hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
|
|
|
|
hists__set_unres_dso_col_len(hists, HISTC_DSO_TO);
|
|
|
|
}
|
|
|
|
}
|
2010-07-20 17:42:52 +00:00
|
|
|
}
|
|
|
|
|
2012-01-04 14:27:03 +00:00
|
|
|
static void hist_entry__add_cpumode_period(struct hist_entry *he,
|
2010-05-14 17:19:35 +00:00
|
|
|
unsigned int cpumode, u64 period)
|
2010-04-19 05:32:50 +00:00
|
|
|
{
|
2010-05-09 16:02:23 +00:00
|
|
|
switch (cpumode) {
|
2010-04-19 05:32:50 +00:00
|
|
|
case PERF_RECORD_MISC_KERNEL:
|
2012-01-04 14:27:03 +00:00
|
|
|
he->period_sys += period;
|
2010-04-19 05:32:50 +00:00
|
|
|
break;
|
|
|
|
case PERF_RECORD_MISC_USER:
|
2012-01-04 14:27:03 +00:00
|
|
|
he->period_us += period;
|
2010-04-19 05:32:50 +00:00
|
|
|
break;
|
|
|
|
case PERF_RECORD_MISC_GUEST_KERNEL:
|
2012-01-04 14:27:03 +00:00
|
|
|
he->period_guest_sys += period;
|
2010-04-19 05:32:50 +00:00
|
|
|
break;
|
|
|
|
case PERF_RECORD_MISC_GUEST_USER:
|
2012-01-04 14:27:03 +00:00
|
|
|
he->period_guest_us += period;
|
2010-04-19 05:32:50 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
perf top: Reuse the 'report' hist_entry/hists classes
This actually fixes several problems we had in the old 'perf top':
1. Unresolved symbols not show, limitation that came from the old
"KernelTop" codebase, to solve it we would need to do changes
that would make sym_entry have most of the hist_entry fields.
2. It was using the number of samples, not the sum of sample->period.
And brings the --sort code that allows us to have all the views in
'perf report', for instance:
[root@emilia ~]# perf top --sort dso
PerfTop: 5903 irqs/sec kernel:77.5% exact: 0.0% [1000Hz cycles], (all, 8 CPUs)
------------------------------------------------------------------------------
31.59% libcrypto.so.1.0.0
21.55% [kernel]
18.57% libpython2.6.so.1.0
7.04% libc-2.12.so
6.99% _backend_agg.so
4.72% sshd
1.48% multiarray.so
1.39% libfreetype.so.6.3.22
1.37% perf
0.71% libgobject-2.0.so.0.2200.5
0.53% [tg3]
0.48% libglib-2.0.so.0.2200.5
0.44% libstdc++.so.6.0.13
0.40% libcairo.so.2.10800.8
0.38% libm-2.12.so
0.34% umath.so
0.30% libgdk-x11-2.0.so.0.1800.9
0.22% libpthread-2.12.so
0.20% libgtk-x11-2.0.so.0.1800.9
0.20% librt-2.12.so
0.15% _path.so
0.13% libpango-1.0.so.0.2800.1
0.11% libatlas.so.3.0
0.09% ft2font.so
0.09% libpangoft2-1.0.so.0.2800.1
0.08% libX11.so.6.3.0
0.07% [vdso]
0.06% cyclictest
^C
All the filter lists can be used as well: --dsos, --comms, --symbols,
etc.
The 'perf report' TUI is also reused, being possible to apply all the
zoom operations, do annotation, etc.
This change will allow multiple simplifications in the symbol system as
well, that will be detailed in upcoming changesets.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-xzaaldxq7zhqrrxdxjifk1mh@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-10-05 22:16:15 +00:00
|
|
|
static void hist_entry__decay(struct hist_entry *he)
|
|
|
|
{
|
|
|
|
he->period = (he->period * 7) / 8;
|
|
|
|
he->nr_events = (he->nr_events * 7) / 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
|
|
|
|
{
|
2011-10-20 08:45:44 +00:00
|
|
|
u64 prev_period = he->period;
|
|
|
|
|
|
|
|
if (prev_period == 0)
|
2011-10-13 11:01:33 +00:00
|
|
|
return true;
|
2011-10-20 08:45:44 +00:00
|
|
|
|
perf top: Reuse the 'report' hist_entry/hists classes
This actually fixes several problems we had in the old 'perf top':
1. Unresolved symbols not show, limitation that came from the old
"KernelTop" codebase, to solve it we would need to do changes
that would make sym_entry have most of the hist_entry fields.
2. It was using the number of samples, not the sum of sample->period.
And brings the --sort code that allows us to have all the views in
'perf report', for instance:
[root@emilia ~]# perf top --sort dso
PerfTop: 5903 irqs/sec kernel:77.5% exact: 0.0% [1000Hz cycles], (all, 8 CPUs)
------------------------------------------------------------------------------
31.59% libcrypto.so.1.0.0
21.55% [kernel]
18.57% libpython2.6.so.1.0
7.04% libc-2.12.so
6.99% _backend_agg.so
4.72% sshd
1.48% multiarray.so
1.39% libfreetype.so.6.3.22
1.37% perf
0.71% libgobject-2.0.so.0.2200.5
0.53% [tg3]
0.48% libglib-2.0.so.0.2200.5
0.44% libstdc++.so.6.0.13
0.40% libcairo.so.2.10800.8
0.38% libm-2.12.so
0.34% umath.so
0.30% libgdk-x11-2.0.so.0.1800.9
0.22% libpthread-2.12.so
0.20% libgtk-x11-2.0.so.0.1800.9
0.20% librt-2.12.so
0.15% _path.so
0.13% libpango-1.0.so.0.2800.1
0.11% libatlas.so.3.0
0.09% ft2font.so
0.09% libpangoft2-1.0.so.0.2800.1
0.08% libX11.so.6.3.0
0.07% [vdso]
0.06% cyclictest
^C
All the filter lists can be used as well: --dsos, --comms, --symbols,
etc.
The 'perf report' TUI is also reused, being possible to apply all the
zoom operations, do annotation, etc.
This change will allow multiple simplifications in the symbol system as
well, that will be detailed in upcoming changesets.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-xzaaldxq7zhqrrxdxjifk1mh@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-10-05 22:16:15 +00:00
|
|
|
hist_entry__decay(he);
|
2011-10-20 08:45:44 +00:00
|
|
|
|
|
|
|
if (!he->filtered)
|
|
|
|
hists->stats.total_period -= prev_period - he->period;
|
|
|
|
|
perf top: Reuse the 'report' hist_entry/hists classes
This actually fixes several problems we had in the old 'perf top':
1. Unresolved symbols not show, limitation that came from the old
"KernelTop" codebase, to solve it we would need to do changes
that would make sym_entry have most of the hist_entry fields.
2. It was using the number of samples, not the sum of sample->period.
And brings the --sort code that allows us to have all the views in
'perf report', for instance:
[root@emilia ~]# perf top --sort dso
PerfTop: 5903 irqs/sec kernel:77.5% exact: 0.0% [1000Hz cycles], (all, 8 CPUs)
------------------------------------------------------------------------------
31.59% libcrypto.so.1.0.0
21.55% [kernel]
18.57% libpython2.6.so.1.0
7.04% libc-2.12.so
6.99% _backend_agg.so
4.72% sshd
1.48% multiarray.so
1.39% libfreetype.so.6.3.22
1.37% perf
0.71% libgobject-2.0.so.0.2200.5
0.53% [tg3]
0.48% libglib-2.0.so.0.2200.5
0.44% libstdc++.so.6.0.13
0.40% libcairo.so.2.10800.8
0.38% libm-2.12.so
0.34% umath.so
0.30% libgdk-x11-2.0.so.0.1800.9
0.22% libpthread-2.12.so
0.20% libgtk-x11-2.0.so.0.1800.9
0.20% librt-2.12.so
0.15% _path.so
0.13% libpango-1.0.so.0.2800.1
0.11% libatlas.so.3.0
0.09% ft2font.so
0.09% libpangoft2-1.0.so.0.2800.1
0.08% libX11.so.6.3.0
0.07% [vdso]
0.06% cyclictest
^C
All the filter lists can be used as well: --dsos, --comms, --symbols,
etc.
The 'perf report' TUI is also reused, being possible to apply all the
zoom operations, do annotation, etc.
This change will allow multiple simplifications in the symbol system as
well, that will be detailed in upcoming changesets.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-xzaaldxq7zhqrrxdxjifk1mh@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-10-05 22:16:15 +00:00
|
|
|
return he->period == 0;
|
|
|
|
}
|
|
|
|
|
2011-10-17 11:05:04 +00:00
|
|
|
static void __hists__decay_entries(struct hists *hists, bool zap_user,
|
|
|
|
bool zap_kernel, bool threaded)
|
perf top: Reuse the 'report' hist_entry/hists classes
This actually fixes several problems we had in the old 'perf top':
1. Unresolved symbols not show, limitation that came from the old
"KernelTop" codebase, to solve it we would need to do changes
that would make sym_entry have most of the hist_entry fields.
2. It was using the number of samples, not the sum of sample->period.
And brings the --sort code that allows us to have all the views in
'perf report', for instance:
[root@emilia ~]# perf top --sort dso
PerfTop: 5903 irqs/sec kernel:77.5% exact: 0.0% [1000Hz cycles], (all, 8 CPUs)
------------------------------------------------------------------------------
31.59% libcrypto.so.1.0.0
21.55% [kernel]
18.57% libpython2.6.so.1.0
7.04% libc-2.12.so
6.99% _backend_agg.so
4.72% sshd
1.48% multiarray.so
1.39% libfreetype.so.6.3.22
1.37% perf
0.71% libgobject-2.0.so.0.2200.5
0.53% [tg3]
0.48% libglib-2.0.so.0.2200.5
0.44% libstdc++.so.6.0.13
0.40% libcairo.so.2.10800.8
0.38% libm-2.12.so
0.34% umath.so
0.30% libgdk-x11-2.0.so.0.1800.9
0.22% libpthread-2.12.so
0.20% libgtk-x11-2.0.so.0.1800.9
0.20% librt-2.12.so
0.15% _path.so
0.13% libpango-1.0.so.0.2800.1
0.11% libatlas.so.3.0
0.09% ft2font.so
0.09% libpangoft2-1.0.so.0.2800.1
0.08% libX11.so.6.3.0
0.07% [vdso]
0.06% cyclictest
^C
All the filter lists can be used as well: --dsos, --comms, --symbols,
etc.
The 'perf report' TUI is also reused, being possible to apply all the
zoom operations, do annotation, etc.
This change will allow multiple simplifications in the symbol system as
well, that will be detailed in upcoming changesets.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-xzaaldxq7zhqrrxdxjifk1mh@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-10-05 22:16:15 +00:00
|
|
|
{
|
|
|
|
struct rb_node *next = rb_first(&hists->entries);
|
|
|
|
struct hist_entry *n;
|
|
|
|
|
|
|
|
while (next) {
|
|
|
|
n = rb_entry(next, struct hist_entry, rb_node);
|
|
|
|
next = rb_next(&n->rb_node);
|
2011-10-13 11:01:33 +00:00
|
|
|
/*
|
|
|
|
* We may be annotating this, for instance, so keep it here in
|
|
|
|
* case some it gets new samples, we'll eventually free it when
|
|
|
|
* the user stops browsing and it agains gets fully decayed.
|
|
|
|
*/
|
2011-10-17 11:05:04 +00:00
|
|
|
if (((zap_user && n->level == '.') ||
|
|
|
|
(zap_kernel && n->level != '.') ||
|
|
|
|
hists__decay_entry(hists, n)) &&
|
|
|
|
!n->used) {
|
perf top: Reuse the 'report' hist_entry/hists classes
This actually fixes several problems we had in the old 'perf top':
1. Unresolved symbols not show, limitation that came from the old
"KernelTop" codebase, to solve it we would need to do changes
that would make sym_entry have most of the hist_entry fields.
2. It was using the number of samples, not the sum of sample->period.
And brings the --sort code that allows us to have all the views in
'perf report', for instance:
[root@emilia ~]# perf top --sort dso
PerfTop: 5903 irqs/sec kernel:77.5% exact: 0.0% [1000Hz cycles], (all, 8 CPUs)
------------------------------------------------------------------------------
31.59% libcrypto.so.1.0.0
21.55% [kernel]
18.57% libpython2.6.so.1.0
7.04% libc-2.12.so
6.99% _backend_agg.so
4.72% sshd
1.48% multiarray.so
1.39% libfreetype.so.6.3.22
1.37% perf
0.71% libgobject-2.0.so.0.2200.5
0.53% [tg3]
0.48% libglib-2.0.so.0.2200.5
0.44% libstdc++.so.6.0.13
0.40% libcairo.so.2.10800.8
0.38% libm-2.12.so
0.34% umath.so
0.30% libgdk-x11-2.0.so.0.1800.9
0.22% libpthread-2.12.so
0.20% libgtk-x11-2.0.so.0.1800.9
0.20% librt-2.12.so
0.15% _path.so
0.13% libpango-1.0.so.0.2800.1
0.11% libatlas.so.3.0
0.09% ft2font.so
0.09% libpangoft2-1.0.so.0.2800.1
0.08% libX11.so.6.3.0
0.07% [vdso]
0.06% cyclictest
^C
All the filter lists can be used as well: --dsos, --comms, --symbols,
etc.
The 'perf report' TUI is also reused, being possible to apply all the
zoom operations, do annotation, etc.
This change will allow multiple simplifications in the symbol system as
well, that will be detailed in upcoming changesets.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-xzaaldxq7zhqrrxdxjifk1mh@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-10-05 22:16:15 +00:00
|
|
|
rb_erase(&n->rb_node, &hists->entries);
|
|
|
|
|
2011-10-13 12:06:54 +00:00
|
|
|
if (sort__need_collapse || threaded)
|
perf top: Reuse the 'report' hist_entry/hists classes
This actually fixes several problems we had in the old 'perf top':
1. Unresolved symbols not show, limitation that came from the old
"KernelTop" codebase, to solve it we would need to do changes
that would make sym_entry have most of the hist_entry fields.
2. It was using the number of samples, not the sum of sample->period.
And brings the --sort code that allows us to have all the views in
'perf report', for instance:
[root@emilia ~]# perf top --sort dso
PerfTop: 5903 irqs/sec kernel:77.5% exact: 0.0% [1000Hz cycles], (all, 8 CPUs)
------------------------------------------------------------------------------
31.59% libcrypto.so.1.0.0
21.55% [kernel]
18.57% libpython2.6.so.1.0
7.04% libc-2.12.so
6.99% _backend_agg.so
4.72% sshd
1.48% multiarray.so
1.39% libfreetype.so.6.3.22
1.37% perf
0.71% libgobject-2.0.so.0.2200.5
0.53% [tg3]
0.48% libglib-2.0.so.0.2200.5
0.44% libstdc++.so.6.0.13
0.40% libcairo.so.2.10800.8
0.38% libm-2.12.so
0.34% umath.so
0.30% libgdk-x11-2.0.so.0.1800.9
0.22% libpthread-2.12.so
0.20% libgtk-x11-2.0.so.0.1800.9
0.20% librt-2.12.so
0.15% _path.so
0.13% libpango-1.0.so.0.2800.1
0.11% libatlas.so.3.0
0.09% ft2font.so
0.09% libpangoft2-1.0.so.0.2800.1
0.08% libX11.so.6.3.0
0.07% [vdso]
0.06% cyclictest
^C
All the filter lists can be used as well: --dsos, --comms, --symbols,
etc.
The 'perf report' TUI is also reused, being possible to apply all the
zoom operations, do annotation, etc.
This change will allow multiple simplifications in the symbol system as
well, that will be detailed in upcoming changesets.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-xzaaldxq7zhqrrxdxjifk1mh@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-10-05 22:16:15 +00:00
|
|
|
rb_erase(&n->rb_node_in, &hists->entries_collapsed);
|
|
|
|
|
|
|
|
hist_entry__free(n);
|
|
|
|
--hists->nr_entries;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-17 11:05:04 +00:00
|
|
|
void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
|
2011-10-13 12:06:54 +00:00
|
|
|
{
|
2011-10-17 11:05:04 +00:00
|
|
|
return __hists__decay_entries(hists, zap_user, zap_kernel, false);
|
2011-10-13 12:06:54 +00:00
|
|
|
}
|
|
|
|
|
2011-10-17 11:05:04 +00:00
|
|
|
void hists__decay_entries_threaded(struct hists *hists,
|
|
|
|
bool zap_user, bool zap_kernel)
|
2011-10-13 12:06:54 +00:00
|
|
|
{
|
2011-10-17 11:05:04 +00:00
|
|
|
return __hists__decay_entries(hists, zap_user, zap_kernel, true);
|
2011-10-13 12:06:54 +00:00
|
|
|
}
|
|
|
|
|
2009-09-28 13:32:55 +00:00
|
|
|
/*
|
2010-05-14 17:19:35 +00:00
|
|
|
* histogram, sorted on item, collects periods
|
2009-09-28 13:32:55 +00:00
|
|
|
*/
|
|
|
|
|
2010-05-09 16:02:23 +00:00
|
|
|
static struct hist_entry *hist_entry__new(struct hist_entry *template)
|
|
|
|
{
|
2010-08-22 18:05:22 +00:00
|
|
|
size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_root) : 0;
|
2012-01-04 14:27:03 +00:00
|
|
|
struct hist_entry *he = malloc(sizeof(*he) + callchain_size);
|
2010-05-09 16:02:23 +00:00
|
|
|
|
2012-01-04 14:27:03 +00:00
|
|
|
if (he != NULL) {
|
|
|
|
*he = *template;
|
|
|
|
he->nr_events = 1;
|
|
|
|
if (he->ms.map)
|
|
|
|
he->ms.map->referenced = true;
|
2010-05-09 16:02:23 +00:00
|
|
|
if (symbol_conf.use_callchain)
|
2012-01-04 14:27:03 +00:00
|
|
|
callchain_init(he->callchain);
|
2010-05-09 16:02:23 +00:00
|
|
|
}
|
|
|
|
|
2012-01-04 14:27:03 +00:00
|
|
|
return he;
|
2010-05-09 16:02:23 +00:00
|
|
|
}
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
static void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h)
|
2010-05-10 16:57:51 +00:00
|
|
|
{
|
2010-07-20 17:42:52 +00:00
|
|
|
if (!h->filtered) {
|
2011-09-26 15:33:28 +00:00
|
|
|
hists__calc_col_len(hists, h);
|
|
|
|
++hists->nr_entries;
|
2011-10-05 20:50:23 +00:00
|
|
|
hists->stats.total_period += h->period;
|
2010-07-20 17:42:52 +00:00
|
|
|
}
|
2010-05-10 16:57:51 +00:00
|
|
|
}
|
|
|
|
|
2010-07-21 12:19:41 +00:00
|
|
|
static u8 symbol__parent_filter(const struct symbol *parent)
|
|
|
|
{
|
|
|
|
if (symbol_conf.exclude_other && parent == NULL)
|
|
|
|
return 1 << HIST_FILTER__PARENT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-09 22:21:01 +00:00
|
|
|
static struct hist_entry *add_hist_entry(struct hists *hists,
|
|
|
|
struct hist_entry *entry,
|
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 16:04:11 +00:00
|
|
|
struct addr_location *al,
|
2012-02-09 22:21:01 +00:00
|
|
|
u64 period)
|
2009-10-03 13:42:45 +00:00
|
|
|
{
|
2011-10-05 20:50:23 +00:00
|
|
|
struct rb_node **p;
|
2009-10-03 13:42:45 +00:00
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct hist_entry *he;
|
|
|
|
int cmp;
|
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
pthread_mutex_lock(&hists->lock);
|
|
|
|
|
|
|
|
p = &hists->entries_in->rb_node;
|
|
|
|
|
2009-10-03 13:42:45 +00:00
|
|
|
while (*p != NULL) {
|
|
|
|
parent = *p;
|
2011-10-05 20:50:23 +00:00
|
|
|
he = rb_entry(parent, struct hist_entry, rb_node_in);
|
2009-10-03 13:42:45 +00:00
|
|
|
|
2012-02-09 22:21:01 +00:00
|
|
|
cmp = hist_entry__cmp(entry, he);
|
2009-10-03 13:42:45 +00:00
|
|
|
|
|
|
|
if (!cmp) {
|
2010-05-14 17:19:35 +00:00
|
|
|
he->period += period;
|
|
|
|
++he->nr_events;
|
2012-03-27 07:14:18 +00:00
|
|
|
|
|
|
|
/* If the map of an existing hist_entry has
|
|
|
|
* become out-of-date due to an exec() or
|
|
|
|
* similar, update it. Otherwise we will
|
|
|
|
* mis-adjust symbol addresses when computing
|
|
|
|
* the history counter to increment.
|
|
|
|
*/
|
|
|
|
if (he->ms.map != entry->ms.map) {
|
|
|
|
he->ms.map = entry->ms.map;
|
|
|
|
if (he->ms.map)
|
|
|
|
he->ms.map->referenced = true;
|
|
|
|
}
|
2010-05-09 16:02:23 +00:00
|
|
|
goto out;
|
2009-10-03 13:42:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cmp < 0)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
}
|
|
|
|
|
2012-02-09 22:21:01 +00:00
|
|
|
he = hist_entry__new(entry);
|
2009-10-03 13:42:45 +00:00
|
|
|
if (!he)
|
2011-10-05 20:50:23 +00:00
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
rb_link_node(&he->rb_node_in, parent, p);
|
|
|
|
rb_insert_color(&he->rb_node_in, hists->entries_in);
|
2010-05-09 16:02:23 +00:00
|
|
|
out:
|
2010-05-14 17:19:35 +00:00
|
|
|
hist_entry__add_cpumode_period(he, al->cpumode, period);
|
2011-10-05 20:50:23 +00:00
|
|
|
out_unlock:
|
|
|
|
pthread_mutex_unlock(&hists->lock);
|
2009-10-03 13:42:45 +00:00
|
|
|
return he;
|
|
|
|
}
|
|
|
|
|
2012-02-09 22:21:01 +00:00
|
|
|
struct hist_entry *__hists__add_branch_entry(struct hists *self,
|
|
|
|
struct addr_location *al,
|
|
|
|
struct symbol *sym_parent,
|
|
|
|
struct branch_info *bi,
|
|
|
|
u64 period)
|
|
|
|
{
|
|
|
|
struct hist_entry entry = {
|
|
|
|
.thread = al->thread,
|
|
|
|
.ms = {
|
|
|
|
.map = bi->to.map,
|
|
|
|
.sym = bi->to.sym,
|
|
|
|
},
|
|
|
|
.cpu = al->cpu,
|
|
|
|
.ip = bi->to.addr,
|
|
|
|
.level = al->level,
|
|
|
|
.period = period,
|
|
|
|
.parent = sym_parent,
|
|
|
|
.filtered = symbol__parent_filter(sym_parent),
|
|
|
|
.branch_info = bi,
|
|
|
|
};
|
|
|
|
|
|
|
|
return add_hist_entry(self, &entry, al, period);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct hist_entry *__hists__add_entry(struct hists *self,
|
|
|
|
struct addr_location *al,
|
|
|
|
struct symbol *sym_parent, u64 period)
|
|
|
|
{
|
|
|
|
struct hist_entry entry = {
|
|
|
|
.thread = al->thread,
|
|
|
|
.ms = {
|
|
|
|
.map = al->map,
|
|
|
|
.sym = al->sym,
|
|
|
|
},
|
|
|
|
.cpu = al->cpu,
|
|
|
|
.ip = al->addr,
|
|
|
|
.level = al->level,
|
|
|
|
.period = period,
|
|
|
|
.parent = sym_parent,
|
|
|
|
.filtered = symbol__parent_filter(sym_parent),
|
|
|
|
};
|
|
|
|
|
|
|
|
return add_hist_entry(self, &entry, al, period);
|
|
|
|
}
|
|
|
|
|
2009-09-28 13:32:55 +00: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 17:11:29 +00:00
|
|
|
cmp = se->se_cmp(left, right);
|
2009-09-28 13:32:55 +00: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 17:11:29 +00:00
|
|
|
f = se->se_collapse ?: se->se_cmp;
|
2009-09-28 13:32:55 +00:00
|
|
|
|
|
|
|
cmp = f(left, right);
|
|
|
|
if (cmp)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void hist_entry__free(struct hist_entry *he)
|
|
|
|
{
|
|
|
|
free(he);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* collapse the histogram
|
|
|
|
*/
|
|
|
|
|
2012-05-31 05:43:26 +00:00
|
|
|
static bool hists__collapse_insert_entry(struct hists *hists __used,
|
2011-01-14 03:51:58 +00:00
|
|
|
struct rb_root *root,
|
|
|
|
struct hist_entry *he)
|
2009-09-28 13:32:55 +00:00
|
|
|
{
|
2009-12-14 13:37:11 +00:00
|
|
|
struct rb_node **p = &root->rb_node;
|
2009-09-28 13:32:55 +00:00
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct hist_entry *iter;
|
|
|
|
int64_t cmp;
|
|
|
|
|
|
|
|
while (*p != NULL) {
|
|
|
|
parent = *p;
|
2011-10-05 20:50:23 +00:00
|
|
|
iter = rb_entry(parent, struct hist_entry, rb_node_in);
|
2009-09-28 13:32:55 +00:00
|
|
|
|
|
|
|
cmp = hist_entry__collapse(iter, he);
|
|
|
|
|
|
|
|
if (!cmp) {
|
2010-05-14 17:19:35 +00:00
|
|
|
iter->period += he->period;
|
2011-10-03 09:38:15 +00:00
|
|
|
iter->nr_events += he->nr_events;
|
2011-01-14 03:51:58 +00:00
|
|
|
if (symbol_conf.use_callchain) {
|
2012-05-31 05:43:26 +00:00
|
|
|
callchain_cursor_reset(&callchain_cursor);
|
|
|
|
callchain_merge(&callchain_cursor,
|
|
|
|
iter->callchain,
|
2011-01-14 03:51:58 +00:00
|
|
|
he->callchain);
|
|
|
|
}
|
2009-09-28 13:32:55 +00:00
|
|
|
hist_entry__free(he);
|
2010-05-10 16:57:51 +00:00
|
|
|
return false;
|
2009-09-28 13:32:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cmp < 0)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
}
|
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
rb_link_node(&he->rb_node_in, parent, p);
|
|
|
|
rb_insert_color(&he->rb_node_in, root);
|
2010-05-10 16:57:51 +00:00
|
|
|
return true;
|
2009-09-28 13:32:55 +00:00
|
|
|
}
|
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
static struct rb_root *hists__get_rotate_entries_in(struct hists *hists)
|
2009-09-28 13:32:55 +00:00
|
|
|
{
|
2011-10-05 20:50:23 +00:00
|
|
|
struct rb_root *root;
|
|
|
|
|
|
|
|
pthread_mutex_lock(&hists->lock);
|
|
|
|
|
|
|
|
root = hists->entries_in;
|
|
|
|
if (++hists->entries_in > &hists->entries_in_array[1])
|
|
|
|
hists->entries_in = &hists->entries_in_array[0];
|
|
|
|
|
|
|
|
pthread_mutex_unlock(&hists->lock);
|
|
|
|
|
|
|
|
return root;
|
|
|
|
}
|
|
|
|
|
2011-10-19 15:09:10 +00:00
|
|
|
static void hists__apply_filters(struct hists *hists, struct hist_entry *he)
|
|
|
|
{
|
|
|
|
hists__filter_entry_by_dso(hists, he);
|
|
|
|
hists__filter_entry_by_thread(hists, he);
|
2012-03-16 08:50:51 +00:00
|
|
|
hists__filter_entry_by_symbol(hists, he);
|
2011-10-19 15:09:10 +00:00
|
|
|
}
|
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
static void __hists__collapse_resort(struct hists *hists, bool threaded)
|
|
|
|
{
|
|
|
|
struct rb_root *root;
|
2009-09-28 13:32:55 +00:00
|
|
|
struct rb_node *next;
|
|
|
|
struct hist_entry *n;
|
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
if (!sort__need_collapse && !threaded)
|
2009-09-28 13:32:55 +00:00
|
|
|
return;
|
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
root = hists__get_rotate_entries_in(hists);
|
|
|
|
next = rb_first(root);
|
2009-12-14 13:37:11 +00:00
|
|
|
|
2009-09-28 13:32:55 +00:00
|
|
|
while (next) {
|
2011-10-05 20:50:23 +00:00
|
|
|
n = rb_entry(next, struct hist_entry, rb_node_in);
|
|
|
|
next = rb_next(&n->rb_node_in);
|
2009-09-28 13:32:55 +00:00
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
rb_erase(&n->rb_node_in, root);
|
2011-10-19 15:09:10 +00:00
|
|
|
if (hists__collapse_insert_entry(hists, &hists->entries_collapsed, n)) {
|
|
|
|
/*
|
|
|
|
* If it wasn't combined with one of the entries already
|
|
|
|
* collapsed, we need to apply the filters that may have
|
|
|
|
* been set by, say, the hist_browser.
|
|
|
|
*/
|
|
|
|
hists__apply_filters(hists, n);
|
|
|
|
}
|
2009-09-28 13:32:55 +00:00
|
|
|
}
|
2011-10-05 20:50:23 +00:00
|
|
|
}
|
2009-12-14 13:37:11 +00:00
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
void hists__collapse_resort(struct hists *hists)
|
|
|
|
{
|
|
|
|
return __hists__collapse_resort(hists, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void hists__collapse_resort_threaded(struct hists *hists)
|
|
|
|
{
|
|
|
|
return __hists__collapse_resort(hists, true);
|
2009-09-28 13:32:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-05-14 17:19:35 +00:00
|
|
|
* reverse the map, sort on period.
|
2009-09-28 13:32:55 +00: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 16:04:11 +00:00
|
|
|
static void __hists__insert_output_entry(struct rb_root *entries,
|
|
|
|
struct hist_entry *he,
|
|
|
|
u64 min_callchain_hits)
|
2009-09-28 13:32:55 +00: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 16:04:11 +00:00
|
|
|
struct rb_node **p = &entries->rb_node;
|
2009-09-28 13:32:55 +00:00
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct hist_entry *iter;
|
|
|
|
|
2009-12-15 22:04:42 +00:00
|
|
|
if (symbol_conf.use_callchain)
|
2010-04-02 12:50:42 +00:00
|
|
|
callchain_param.sort(&he->sorted_chain, he->callchain,
|
2009-09-28 13:32:55 +00:00
|
|
|
min_callchain_hits, &callchain_param);
|
|
|
|
|
|
|
|
while (*p != NULL) {
|
|
|
|
parent = *p;
|
|
|
|
iter = rb_entry(parent, struct hist_entry, rb_node);
|
|
|
|
|
2010-05-14 17:19:35 +00:00
|
|
|
if (he->period > iter->period)
|
2009-09-28 13:32:55 +00: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 16:04:11 +00:00
|
|
|
rb_insert_color(&he->rb_node, entries);
|
2009-09-28 13:32:55 +00:00
|
|
|
}
|
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
static void __hists__output_resort(struct hists *hists, bool threaded)
|
2009-09-28 13:32:55 +00:00
|
|
|
{
|
2011-10-05 20:50:23 +00:00
|
|
|
struct rb_root *root;
|
2009-09-28 13:32:55 +00:00
|
|
|
struct rb_node *next;
|
|
|
|
struct hist_entry *n;
|
|
|
|
u64 min_callchain_hits;
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
min_callchain_hits = hists->stats.total_period * (callchain_param.min_percent / 100);
|
2009-09-28 13:32:55 +00:00
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
if (sort__need_collapse || threaded)
|
|
|
|
root = &hists->entries_collapsed;
|
|
|
|
else
|
|
|
|
root = hists->entries_in;
|
|
|
|
|
|
|
|
next = rb_first(root);
|
|
|
|
hists->entries = RB_ROOT;
|
2009-09-28 13:32:55 +00:00
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
hists->nr_entries = 0;
|
2011-10-27 11:19:48 +00:00
|
|
|
hists->stats.total_period = 0;
|
2011-09-26 15:33:28 +00:00
|
|
|
hists__reset_col_len(hists);
|
2010-05-10 16:57:51 +00:00
|
|
|
|
2009-09-28 13:32:55 +00:00
|
|
|
while (next) {
|
2011-10-05 20:50:23 +00:00
|
|
|
n = rb_entry(next, struct hist_entry, rb_node_in);
|
|
|
|
next = rb_next(&n->rb_node_in);
|
2009-09-28 13:32:55 +00:00
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
__hists__insert_output_entry(&hists->entries, n, min_callchain_hits);
|
2011-09-26 15:33:28 +00:00
|
|
|
hists__inc_nr_entries(hists, n);
|
2009-09-28 13:32:55 +00:00
|
|
|
}
|
2011-10-05 20:50:23 +00:00
|
|
|
}
|
2009-12-14 13:37:11 +00:00
|
|
|
|
2011-10-05 20:50:23 +00:00
|
|
|
void hists__output_resort(struct hists *hists)
|
|
|
|
{
|
|
|
|
return __hists__output_resort(hists, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void hists__output_resort_threaded(struct hists *hists)
|
|
|
|
{
|
|
|
|
return __hists__output_resort(hists, true);
|
2009-09-28 13:32:55 +00:00
|
|
|
}
|
2009-12-16 14:27:09 +00: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 17:19:35 +00:00
|
|
|
int depth, int depth_mask, int period,
|
2011-01-03 15:13:11 +00:00
|
|
|
u64 total_samples, u64 hits,
|
2009-12-16 14:27:09 +00:00
|
|
|
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 17:19:35 +00:00
|
|
|
if (!period && i == depth - 1) {
|
2009-12-16 14:27:09 +00: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 19:40:18 +00:00
|
|
|
if (chain->ms.sym)
|
|
|
|
ret += fprintf(fp, "%s\n", chain->ms.sym->name);
|
2009-12-16 14:27:09 +00:00
|
|
|
else
|
2012-05-16 06:59:08 +00:00
|
|
|
ret += fprintf(fp, "0x%0" PRIx64 "\n", chain->ip);
|
2009-12-16 14:27:09 +00:00
|
|
|
|
|
|
|
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 19:40:18 +00:00
|
|
|
rem_hits.ms.sym = rem_sq_bracket;
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
static size_t __callchain__fprintf_graph(FILE *fp, struct rb_root *root,
|
2009-12-16 14:27:09 +00:00
|
|
|
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 remaining;
|
|
|
|
size_t ret = 0;
|
|
|
|
int i;
|
2010-05-09 23:28:10 +00:00
|
|
|
uint entries_printed = 0;
|
2009-12-16 14:27:09 +00:00
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
remaining = total_samples;
|
2009-12-16 14:27:09 +00:00
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
node = rb_first(root);
|
2009-12-16 14:27:09 +00:00
|
|
|
while (node) {
|
2012-03-23 18:06:50 +00:00
|
|
|
u64 new_total;
|
2009-12-16 14:27:09 +00:00
|
|
|
u64 cumul;
|
|
|
|
|
|
|
|
child = rb_entry(node, struct callchain_node, rb_node);
|
2011-01-14 03:51:59 +00:00
|
|
|
cumul = callchain_cumul_hits(child);
|
2009-12-16 14:27:09 +00:00
|
|
|
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 00:01:28 +00:00
|
|
|
* But we keep the older depth mask for the line separator
|
2009-12-16 14:27:09 +00: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++,
|
2012-03-23 18:06:50 +00:00
|
|
|
total_samples,
|
2009-12-16 14:27:09 +00:00
|
|
|
cumul,
|
|
|
|
left_margin);
|
|
|
|
}
|
2012-03-23 18:06:50 +00:00
|
|
|
|
|
|
|
if (callchain_param.mode == CHAIN_GRAPH_REL)
|
|
|
|
new_total = child->children_hit;
|
|
|
|
else
|
|
|
|
new_total = total_samples;
|
|
|
|
|
|
|
|
ret += __callchain__fprintf_graph(fp, &child->rb_root, new_total,
|
2009-12-16 14:27:09 +00:00
|
|
|
depth + 1,
|
|
|
|
new_depth_mask | (1 << depth),
|
|
|
|
left_margin);
|
|
|
|
node = next;
|
2010-05-09 23:28:10 +00:00
|
|
|
if (++entries_printed == callchain_param.print_limit)
|
|
|
|
break;
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (callchain_param.mode == CHAIN_GRAPH_REL &&
|
2012-03-23 18:06:50 +00:00
|
|
|
remaining && remaining != total_samples) {
|
2009-12-16 14:27:09 +00:00
|
|
|
|
|
|
|
if (!rem_sq_bracket)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
new_depth_mask &= ~(1 << (depth - 1));
|
|
|
|
ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
|
2012-03-23 18:06:50 +00:00
|
|
|
new_depth_mask, 0, total_samples,
|
2009-12-16 14:27:09 +00:00
|
|
|
remaining, left_margin);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
|
2009-12-16 14:27:09 +00:00
|
|
|
u64 total_samples, int left_margin)
|
|
|
|
{
|
2012-03-23 18:06:50 +00:00
|
|
|
struct callchain_node *cnode;
|
2009-12-16 14:27:09 +00:00
|
|
|
struct callchain_list *chain;
|
2012-03-23 18:06:50 +00:00
|
|
|
u32 entries_printed = 0;
|
2009-12-16 14:27:09 +00:00
|
|
|
bool printed = false;
|
2012-03-23 18:06:50 +00:00
|
|
|
struct rb_node *node;
|
2009-12-16 14:27:09 +00:00
|
|
|
int i = 0;
|
2012-07-18 17:10:55 +00:00
|
|
|
int ret = 0;
|
2010-05-09 23:28:10 +00:00
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
/*
|
|
|
|
* If have one single callchain root, don't bother printing
|
|
|
|
* its percentage (100 % in fractal mode and the same percentage
|
|
|
|
* than the hist in graph mode). This also avoid one level of column.
|
|
|
|
*/
|
|
|
|
node = rb_first(root);
|
|
|
|
if (node && !rb_next(node)) {
|
|
|
|
cnode = rb_entry(node, struct callchain_node, rb_node);
|
|
|
|
list_for_each_entry(chain, &cnode->val, list) {
|
|
|
|
/*
|
|
|
|
* If we sort by symbol, the first entry is the same than
|
|
|
|
* the symbol. No need to print it otherwise it appears as
|
|
|
|
* displayed twice.
|
|
|
|
*/
|
|
|
|
if (!i++ && sort__first_dimension == SORT_SYM)
|
|
|
|
continue;
|
|
|
|
if (!printed) {
|
|
|
|
ret += callchain__fprintf_left_margin(fp, left_margin);
|
|
|
|
ret += fprintf(fp, "|\n");
|
|
|
|
ret += callchain__fprintf_left_margin(fp, left_margin);
|
|
|
|
ret += fprintf(fp, "---");
|
|
|
|
left_margin += 3;
|
|
|
|
printed = true;
|
|
|
|
} else
|
|
|
|
ret += callchain__fprintf_left_margin(fp, left_margin);
|
|
|
|
|
|
|
|
if (chain->ms.sym)
|
|
|
|
ret += fprintf(fp, " %s\n", chain->ms.sym->name);
|
|
|
|
else
|
|
|
|
ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
|
|
|
|
|
|
|
|
if (++entries_printed == callchain_param.print_limit)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
root = &cnode->rb_root;
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
|
|
|
|
2012-07-18 17:10:55 +00:00
|
|
|
ret += __callchain__fprintf_graph(fp, root, total_samples,
|
2012-03-23 18:06:50 +00:00
|
|
|
1, 1, left_margin);
|
2012-07-18 17:10:56 +00:00
|
|
|
ret += fprintf(fp, "\n");
|
|
|
|
|
2012-07-18 17:10:55 +00:00
|
|
|
return ret;
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
static size_t __callchain__fprintf_flat(FILE *fp,
|
|
|
|
struct callchain_node *self,
|
|
|
|
u64 total_samples)
|
2009-12-16 14:27:09 +00:00
|
|
|
{
|
|
|
|
struct callchain_list *chain;
|
|
|
|
size_t ret = 0;
|
|
|
|
|
|
|
|
if (!self)
|
|
|
|
return 0;
|
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
ret += __callchain__fprintf_flat(fp, self->parent, total_samples);
|
2009-12-16 14:27:09 +00:00
|
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(chain, &self->val, list) {
|
|
|
|
if (chain->ip >= PERF_CONTEXT_MAX)
|
|
|
|
continue;
|
2010-03-24 19:40:18 +00:00
|
|
|
if (chain->ms.sym)
|
|
|
|
ret += fprintf(fp, " %s\n", chain->ms.sym->name);
|
2009-12-16 14:27:09 +00:00
|
|
|
else
|
|
|
|
ret += fprintf(fp, " %p\n",
|
|
|
|
(void *)(long)chain->ip);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
static size_t callchain__fprintf_flat(FILE *fp, struct rb_root *self,
|
|
|
|
u64 total_samples)
|
2009-12-16 14:27:09 +00:00
|
|
|
{
|
|
|
|
size_t ret = 0;
|
2010-05-09 23:28:10 +00:00
|
|
|
u32 entries_printed = 0;
|
2012-03-23 18:06:50 +00:00
|
|
|
struct rb_node *rb_node;
|
|
|
|
struct callchain_node *chain;
|
2009-12-16 14:27:09 +00:00
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
rb_node = rb_first(self);
|
2009-12-16 14:27:09 +00:00
|
|
|
while (rb_node) {
|
|
|
|
double percent;
|
|
|
|
|
|
|
|
chain = rb_entry(rb_node, struct callchain_node, rb_node);
|
|
|
|
percent = chain->hit * 100.0 / total_samples;
|
2012-03-23 18:06:50 +00:00
|
|
|
|
|
|
|
ret = percent_color_fprintf(fp, " %6.2f%%\n", percent);
|
|
|
|
ret += __callchain__fprintf_flat(fp, chain, total_samples);
|
2009-12-16 14:27:09 +00:00
|
|
|
ret += fprintf(fp, "\n");
|
2010-05-09 23:28:10 +00:00
|
|
|
if (++entries_printed == callchain_param.print_limit)
|
|
|
|
break;
|
2012-03-23 18:06:50 +00:00
|
|
|
|
2009-12-16 14:27:09 +00:00
|
|
|
rb_node = rb_next(rb_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-03-23 18:06:50 +00:00
|
|
|
static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
|
|
|
|
u64 total_samples, int left_margin,
|
|
|
|
FILE *fp)
|
|
|
|
{
|
|
|
|
switch (callchain_param.mode) {
|
|
|
|
case CHAIN_GRAPH_REL:
|
|
|
|
return callchain__fprintf_graph(fp, &he->sorted_chain, he->period,
|
|
|
|
left_margin);
|
|
|
|
break;
|
|
|
|
case CHAIN_GRAPH_ABS:
|
|
|
|
return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
|
|
|
|
left_margin);
|
|
|
|
break;
|
|
|
|
case CHAIN_FLAT:
|
|
|
|
return callchain__fprintf_flat(fp, &he->sorted_chain, total_samples);
|
|
|
|
break;
|
|
|
|
case CHAIN_NONE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pr_err("Bad callchain mode\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
perf top: Reuse the 'report' hist_entry/hists classes
This actually fixes several problems we had in the old 'perf top':
1. Unresolved symbols not show, limitation that came from the old
"KernelTop" codebase, to solve it we would need to do changes
that would make sym_entry have most of the hist_entry fields.
2. It was using the number of samples, not the sum of sample->period.
And brings the --sort code that allows us to have all the views in
'perf report', for instance:
[root@emilia ~]# perf top --sort dso
PerfTop: 5903 irqs/sec kernel:77.5% exact: 0.0% [1000Hz cycles], (all, 8 CPUs)
------------------------------------------------------------------------------
31.59% libcrypto.so.1.0.0
21.55% [kernel]
18.57% libpython2.6.so.1.0
7.04% libc-2.12.so
6.99% _backend_agg.so
4.72% sshd
1.48% multiarray.so
1.39% libfreetype.so.6.3.22
1.37% perf
0.71% libgobject-2.0.so.0.2200.5
0.53% [tg3]
0.48% libglib-2.0.so.0.2200.5
0.44% libstdc++.so.6.0.13
0.40% libcairo.so.2.10800.8
0.38% libm-2.12.so
0.34% umath.so
0.30% libgdk-x11-2.0.so.0.1800.9
0.22% libpthread-2.12.so
0.20% libgtk-x11-2.0.so.0.1800.9
0.20% librt-2.12.so
0.15% _path.so
0.13% libpango-1.0.so.0.2800.1
0.11% libatlas.so.3.0
0.09% ft2font.so
0.09% libpangoft2-1.0.so.0.2800.1
0.08% libX11.so.6.3.0
0.07% [vdso]
0.06% cyclictest
^C
All the filter lists can be used as well: --dsos, --comms, --symbols,
etc.
The 'perf report' TUI is also reused, being possible to apply all the
zoom operations, do annotation, etc.
This change will allow multiple simplifications in the symbol system as
well, that will be detailed in upcoming changesets.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-xzaaldxq7zhqrrxdxjifk1mh@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-10-05 22:16:15 +00:00
|
|
|
void hists__output_recalc_col_len(struct hists *hists, int max_rows)
|
|
|
|
{
|
|
|
|
struct rb_node *next = rb_first(&hists->entries);
|
|
|
|
struct hist_entry *n;
|
|
|
|
int row = 0;
|
|
|
|
|
|
|
|
hists__reset_col_len(hists);
|
|
|
|
|
|
|
|
while (next && row++ < max_rows) {
|
|
|
|
n = rb_entry(next, struct hist_entry, rb_node);
|
2011-10-20 09:35:45 +00:00
|
|
|
if (!n->filtered)
|
|
|
|
hists__calc_col_len(hists, n);
|
perf top: Reuse the 'report' hist_entry/hists classes
This actually fixes several problems we had in the old 'perf top':
1. Unresolved symbols not show, limitation that came from the old
"KernelTop" codebase, to solve it we would need to do changes
that would make sym_entry have most of the hist_entry fields.
2. It was using the number of samples, not the sum of sample->period.
And brings the --sort code that allows us to have all the views in
'perf report', for instance:
[root@emilia ~]# perf top --sort dso
PerfTop: 5903 irqs/sec kernel:77.5% exact: 0.0% [1000Hz cycles], (all, 8 CPUs)
------------------------------------------------------------------------------
31.59% libcrypto.so.1.0.0
21.55% [kernel]
18.57% libpython2.6.so.1.0
7.04% libc-2.12.so
6.99% _backend_agg.so
4.72% sshd
1.48% multiarray.so
1.39% libfreetype.so.6.3.22
1.37% perf
0.71% libgobject-2.0.so.0.2200.5
0.53% [tg3]
0.48% libglib-2.0.so.0.2200.5
0.44% libstdc++.so.6.0.13
0.40% libcairo.so.2.10800.8
0.38% libm-2.12.so
0.34% umath.so
0.30% libgdk-x11-2.0.so.0.1800.9
0.22% libpthread-2.12.so
0.20% libgtk-x11-2.0.so.0.1800.9
0.20% librt-2.12.so
0.15% _path.so
0.13% libpango-1.0.so.0.2800.1
0.11% libatlas.so.3.0
0.09% ft2font.so
0.09% libpangoft2-1.0.so.0.2800.1
0.08% libX11.so.6.3.0
0.07% [vdso]
0.06% cyclictest
^C
All the filter lists can be used as well: --dsos, --comms, --symbols,
etc.
The 'perf report' TUI is also reused, being possible to apply all the
zoom operations, do annotation, etc.
This change will allow multiple simplifications in the symbol system as
well, that will be detailed in upcoming changesets.
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-xzaaldxq7zhqrrxdxjifk1mh@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2011-10-05 22:16:15 +00:00
|
|
|
next = rb_next(&n->rb_node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-04 14:27:03 +00:00
|
|
|
static int hist_entry__pcnt_snprintf(struct hist_entry *he, char *s,
|
2011-10-18 16:37:34 +00:00
|
|
|
size_t size, struct hists *pair_hists,
|
|
|
|
bool show_displacement, long displacement,
|
2012-01-04 13:37:15 +00:00
|
|
|
bool color, u64 total_period)
|
2009-12-16 14:27:09 +00:00
|
|
|
{
|
2010-05-14 17:19:35 +00:00
|
|
|
u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
|
2011-02-17 12:37:23 +00:00
|
|
|
u64 nr_events;
|
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 15:49:27 +00:00
|
|
|
const char *sep = symbol_conf.field_sep;
|
2010-03-31 14:33:40 +00:00
|
|
|
int ret;
|
2009-12-16 14:27:09 +00:00
|
|
|
|
2012-01-04 14:27:03 +00:00
|
|
|
if (symbol_conf.exclude_other && !he->parent)
|
2009-12-16 14:27:09 +00:00
|
|
|
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 16:04:11 +00:00
|
|
|
if (pair_hists) {
|
2012-01-04 14:27:03 +00:00
|
|
|
period = he->pair ? he->pair->period : 0;
|
|
|
|
nr_events = he->pair ? he->pair->nr_events : 0;
|
2010-05-14 16:16:55 +00:00
|
|
|
total = pair_hists->stats.total_period;
|
2012-01-04 14:27:03 +00:00
|
|
|
period_sys = he->pair ? he->pair->period_sys : 0;
|
|
|
|
period_us = he->pair ? he->pair->period_us : 0;
|
|
|
|
period_guest_sys = he->pair ? he->pair->period_guest_sys : 0;
|
|
|
|
period_guest_us = he->pair ? he->pair->period_guest_us : 0;
|
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 15:49:27 +00:00
|
|
|
} else {
|
2012-01-04 14:27:03 +00:00
|
|
|
period = he->period;
|
|
|
|
nr_events = he->nr_events;
|
2012-01-04 13:37:15 +00:00
|
|
|
total = total_period;
|
2012-01-04 14:27:03 +00:00
|
|
|
period_sys = he->period_sys;
|
|
|
|
period_us = he->period_us;
|
|
|
|
period_guest_sys = he->period_guest_sys;
|
|
|
|
period_guest_us = he->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 15:49:27 +00:00
|
|
|
}
|
|
|
|
|
2010-03-31 14:33:40 +00:00
|
|
|
if (total) {
|
|
|
|
if (color)
|
|
|
|
ret = percent_color_snprintf(s, size,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 17:19:35 +00:00
|
|
|
(period * 100.0) / total);
|
2010-03-31 14:33:40 +00:00
|
|
|
else
|
2012-03-14 15:29:29 +00:00
|
|
|
ret = scnprintf(s, size, sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 17:19:35 +00:00
|
|
|
(period * 100.0) / total);
|
2010-04-19 05:32:50 +00:00
|
|
|
if (symbol_conf.show_cpu_utilization) {
|
|
|
|
ret += percent_color_snprintf(s + ret, size - ret,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 17:19:35 +00:00
|
|
|
(period_sys * 100.0) / total);
|
2010-04-19 05:32:50 +00:00
|
|
|
ret += percent_color_snprintf(s + ret, size - ret,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 17:19:35 +00:00
|
|
|
(period_us * 100.0) / total);
|
2010-04-19 05:32:50 +00:00
|
|
|
if (perf_guest) {
|
|
|
|
ret += percent_color_snprintf(s + ret,
|
|
|
|
size - ret,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 17:19:35 +00:00
|
|
|
(period_guest_sys * 100.0) /
|
2010-04-19 05:32:50 +00:00
|
|
|
total);
|
|
|
|
ret += percent_color_snprintf(s + ret,
|
|
|
|
size - ret,
|
|
|
|
sep ? "%.2f" : " %6.2f%%",
|
2010-05-14 17:19:35 +00:00
|
|
|
(period_guest_us * 100.0) /
|
2010-04-19 05:32:50 +00:00
|
|
|
total);
|
|
|
|
}
|
|
|
|
}
|
2010-03-31 14:33:40 +00:00
|
|
|
} else
|
2012-03-14 15:29:29 +00:00
|
|
|
ret = scnprintf(s, size, sep ? "%" PRIu64 : "%12" PRIu64 " ", period);
|
2009-12-16 14:27:09 +00: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 15:49:27 +00:00
|
|
|
if (sep)
|
2012-03-14 15:29:29 +00:00
|
|
|
ret += scnprintf(s + ret, size - ret, "%c%" PRIu64, *sep, nr_events);
|
2009-12-16 14:27:09 +00:00
|
|
|
else
|
2012-03-14 15:29:29 +00:00
|
|
|
ret += scnprintf(s + ret, size - ret, "%11" PRIu64, nr_events);
|
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 15:49:27 +00:00
|
|
|
}
|
|
|
|
|
2011-10-05 19:10:06 +00:00
|
|
|
if (symbol_conf.show_total_period) {
|
|
|
|
if (sep)
|
2012-03-14 15:29:29 +00:00
|
|
|
ret += scnprintf(s + ret, size - ret, "%c%" PRIu64, *sep, period);
|
2011-10-05 19:10:06 +00:00
|
|
|
else
|
2012-03-14 15:29:29 +00:00
|
|
|
ret += scnprintf(s + ret, size - ret, " %12" PRIu64, period);
|
2011-10-05 19:10:06 +00: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 16:04:11 +00: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 15:49:27 +00:00
|
|
|
char bf[32];
|
|
|
|
double old_percent = 0, new_percent = 0, diff;
|
|
|
|
|
|
|
|
if (total > 0)
|
2010-05-14 17:19:35 +00:00
|
|
|
old_percent = (period * 100.0) / total;
|
2012-01-04 13:37:15 +00:00
|
|
|
if (total_period > 0)
|
2012-01-04 14:27:03 +00:00
|
|
|
new_percent = (he->period * 100.0) / total_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 15:49:27 +00:00
|
|
|
|
2009-12-16 16:31:49 +00: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 15:49:27 +00:00
|
|
|
|
2009-12-16 16:31:49 +00:00
|
|
|
if (fabs(diff) >= 0.01)
|
2012-03-22 13:37:26 +00:00
|
|
|
scnprintf(bf, sizeof(bf), "%+4.2F%%", diff);
|
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 15:49:27 +00:00
|
|
|
else
|
2012-03-22 13:37:26 +00:00
|
|
|
scnprintf(bf, sizeof(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 15:49:27 +00:00
|
|
|
|
|
|
|
if (sep)
|
2012-03-14 15:29:29 +00:00
|
|
|
ret += scnprintf(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 15:49:27 +00:00
|
|
|
else
|
2012-03-14 15:29:29 +00:00
|
|
|
ret += scnprintf(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 15:49:27 +00:00
|
|
|
|
|
|
|
if (show_displacement) {
|
|
|
|
if (displacement)
|
2012-03-22 13:37:26 +00:00
|
|
|
scnprintf(bf, sizeof(bf), "%+4ld", displacement);
|
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 15:49:27 +00:00
|
|
|
else
|
2012-03-22 13:37:26 +00:00
|
|
|
scnprintf(bf, sizeof(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 15:49:27 +00:00
|
|
|
|
|
|
|
if (sep)
|
2012-03-14 15:29:29 +00:00
|
|
|
ret += scnprintf(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 15:49:27 +00:00
|
|
|
else
|
2012-03-14 15:29:29 +00:00
|
|
|
ret += scnprintf(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 15:49:27 +00:00
|
|
|
}
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
|
|
|
|
2011-10-18 16:37:34 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int hist_entry__snprintf(struct hist_entry *he, char *s, size_t size,
|
|
|
|
struct hists *hists)
|
|
|
|
{
|
|
|
|
const char *sep = symbol_conf.field_sep;
|
|
|
|
struct sort_entry *se;
|
|
|
|
int ret = 0;
|
|
|
|
|
2009-12-16 14:27:09 +00:00
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
|
|
if (se->elide)
|
|
|
|
continue;
|
|
|
|
|
2012-03-14 15:29:29 +00:00
|
|
|
ret += scnprintf(s + ret, size - ret, "%s", sep ?: " ");
|
2011-10-18 16:37:34 +00:00
|
|
|
ret += se->se_snprintf(he, s + ret, size - ret,
|
2010-07-20 17:42:52 +00:00
|
|
|
hists__col_len(hists, se->se_width_idx));
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
|
|
|
|
2010-03-31 14:33:40 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-04 14:27:03 +00:00
|
|
|
static int hist_entry__fprintf(struct hist_entry *he, size_t size,
|
|
|
|
struct hists *hists, struct hists *pair_hists,
|
|
|
|
bool show_displacement, long displacement,
|
|
|
|
u64 total_period, FILE *fp)
|
2010-03-31 14:33:40 +00:00
|
|
|
{
|
|
|
|
char bf[512];
|
2011-10-18 16:37:34 +00:00
|
|
|
int ret;
|
2011-09-26 15:46:11 +00:00
|
|
|
|
|
|
|
if (size == 0 || size > sizeof(bf))
|
|
|
|
size = sizeof(bf);
|
|
|
|
|
2011-10-18 16:37:34 +00:00
|
|
|
ret = hist_entry__pcnt_snprintf(he, bf, size, pair_hists,
|
|
|
|
show_displacement, displacement,
|
2012-01-04 13:37:15 +00:00
|
|
|
true, total_period);
|
2011-10-18 16:37:34 +00:00
|
|
|
hist_entry__snprintf(he, bf + ret, size - ret, hists);
|
2010-03-31 14:33:40 +00:00
|
|
|
return fprintf(fp, "%s\n", bf);
|
2010-03-12 15:46:48 +00:00
|
|
|
}
|
2009-12-16 14:27:09 +00:00
|
|
|
|
2012-01-04 14:27:03 +00:00
|
|
|
static size_t hist_entry__fprintf_callchain(struct hist_entry *he,
|
|
|
|
struct hists *hists,
|
|
|
|
u64 total_period, FILE *fp)
|
2010-03-12 15:46:48 +00:00
|
|
|
{
|
|
|
|
int left_margin = 0;
|
2009-12-16 14:27:09 +00:00
|
|
|
|
2010-03-12 15:46:48 +00:00
|
|
|
if (sort__first_dimension == SORT_COMM) {
|
|
|
|
struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
|
|
|
|
typeof(*se), list);
|
2010-07-20 17:42:52 +00:00
|
|
|
left_margin = hists__col_len(hists, se->se_width_idx);
|
2012-01-04 14:27:03 +00:00
|
|
|
left_margin -= thread__comm_len(he->thread);
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
|
|
|
|
2012-01-04 14:27:03 +00:00
|
|
|
return hist_entry_callchain__fprintf(he, total_period, left_margin, fp);
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
size_t hists__fprintf(struct hists *hists, struct hists *pair,
|
2011-09-26 15:46:11 +00:00
|
|
|
bool show_displacement, bool show_header, int max_rows,
|
|
|
|
int max_cols, FILE *fp)
|
2009-12-16 14:27:09 +00:00
|
|
|
{
|
|
|
|
struct sort_entry *se;
|
|
|
|
struct rb_node *nd;
|
|
|
|
size_t ret = 0;
|
2012-01-04 14:27:03 +00:00
|
|
|
u64 total_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 15:49:27 +00:00
|
|
|
unsigned long position = 1;
|
|
|
|
long displacement = 0;
|
2009-12-16 14:27:09 +00: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 15:49:27 +00:00
|
|
|
const char *sep = symbol_conf.field_sep;
|
2010-05-17 19:22:41 +00:00
|
|
|
const char *col_width = symbol_conf.col_width_list_str;
|
2011-09-26 15:46:11 +00:00
|
|
|
int nr_rows = 0;
|
2009-12-16 14:27:09 +00:00
|
|
|
|
|
|
|
init_rem_hits();
|
|
|
|
|
2011-09-26 15:46:11 +00:00
|
|
|
if (!show_header)
|
|
|
|
goto print_entries;
|
|
|
|
|
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 15:49:27 +00:00
|
|
|
fprintf(fp, "# %s", pair ? "Baseline" : "Overhead");
|
|
|
|
|
2010-04-19 05:32:50 +00: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 {
|
2012-01-07 17:25:32 +00:00
|
|
|
ret += fprintf(fp, " sys ");
|
|
|
|
ret += fprintf(fp, " us ");
|
2010-04-19 05:32:50 +00:00
|
|
|
if (perf_guest) {
|
|
|
|
ret += fprintf(fp, " guest sys ");
|
|
|
|
ret += fprintf(fp, " guest us ");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-07 17:25:32 +00:00
|
|
|
if (symbol_conf.show_nr_samples) {
|
|
|
|
if (sep)
|
|
|
|
fprintf(fp, "%cSamples", *sep);
|
|
|
|
else
|
|
|
|
fputs(" Samples ", fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (symbol_conf.show_total_period) {
|
|
|
|
if (sep)
|
|
|
|
ret += fprintf(fp, "%cPeriod", *sep);
|
|
|
|
else
|
|
|
|
ret += fprintf(fp, " Period ");
|
|
|
|
}
|
|
|
|
|
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 15:49:27 +00: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 14:27:09 +00: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 15:49:27 +00:00
|
|
|
if (sep) {
|
2010-04-14 17:11:29 +00:00
|
|
|
fprintf(fp, "%c%s", *sep, se->se_header);
|
2009-12-16 14:27:09 +00:00
|
|
|
continue;
|
|
|
|
}
|
2010-04-14 17:11:29 +00:00
|
|
|
width = strlen(se->se_header);
|
2010-07-20 17:42:52 +00:00
|
|
|
if (symbol_conf.col_width_list_str) {
|
|
|
|
if (col_width) {
|
2011-09-26 15:33:28 +00:00
|
|
|
hists__set_col_len(hists, se->se_width_idx,
|
2010-07-20 17:42:52 +00:00
|
|
|
atoi(col_width));
|
|
|
|
col_width = strchr(col_width, ',');
|
|
|
|
if (col_width)
|
|
|
|
++col_width;
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
|
|
|
}
|
2011-09-26 15:33:28 +00:00
|
|
|
if (!hists__new_col_len(hists, se->se_width_idx, width))
|
|
|
|
width = hists__col_len(hists, se->se_width_idx);
|
2010-04-14 17:11:29 +00:00
|
|
|
fprintf(fp, " %*s", width, se->se_header);
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
2011-09-26 15:46:11 +00:00
|
|
|
|
2009-12-16 14:27:09 +00:00
|
|
|
fprintf(fp, "\n");
|
2011-09-26 15:46:11 +00:00
|
|
|
if (max_rows && ++nr_rows >= max_rows)
|
|
|
|
goto out;
|
2009-12-16 14:27:09 +00:00
|
|
|
|
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 15:49:27 +00:00
|
|
|
if (sep)
|
2009-12-16 14:27:09 +00:00
|
|
|
goto print_entries;
|
|
|
|
|
|
|
|
fprintf(fp, "# ........");
|
2012-01-07 17:25:32 +00:00
|
|
|
if (symbol_conf.show_cpu_utilization)
|
|
|
|
fprintf(fp, " ....... .......");
|
2009-12-16 14:27:09 +00:00
|
|
|
if (symbol_conf.show_nr_samples)
|
|
|
|
fprintf(fp, " ..........");
|
2011-10-05 19:10:06 +00:00
|
|
|
if (symbol_conf.show_total_period)
|
|
|
|
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 15:49:27 +00:00
|
|
|
if (pair) {
|
|
|
|
fprintf(fp, " ..........");
|
|
|
|
if (show_displacement)
|
|
|
|
fprintf(fp, " .....");
|
|
|
|
}
|
2009-12-16 14:27:09 +00:00
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list) {
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
if (se->elide)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
fprintf(fp, " ");
|
2011-09-26 15:33:28 +00:00
|
|
|
width = hists__col_len(hists, se->se_width_idx);
|
2010-07-20 17:42:52 +00:00
|
|
|
if (width == 0)
|
2010-04-14 17:11:29 +00:00
|
|
|
width = strlen(se->se_header);
|
2009-12-16 14:27:09 +00:00
|
|
|
for (i = 0; i < width; i++)
|
|
|
|
fprintf(fp, ".");
|
|
|
|
}
|
|
|
|
|
2011-09-26 15:46:11 +00:00
|
|
|
fprintf(fp, "\n");
|
|
|
|
if (max_rows && ++nr_rows >= max_rows)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
fprintf(fp, "#\n");
|
|
|
|
if (max_rows && ++nr_rows >= max_rows)
|
|
|
|
goto out;
|
2009-12-16 14:27:09 +00:00
|
|
|
|
|
|
|
print_entries:
|
2012-01-04 14:27:03 +00:00
|
|
|
total_period = hists->stats.total_period;
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
for (nd = rb_first(&hists->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 15:49:27 +00:00
|
|
|
struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
|
|
|
|
|
2011-06-29 20:23:03 +00:00
|
|
|
if (h->filtered)
|
|
|
|
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 15:49:27 +00:00
|
|
|
if (show_displacement) {
|
|
|
|
if (h->pair != NULL)
|
|
|
|
displacement = ((long)h->pair->position -
|
|
|
|
(long)position);
|
|
|
|
else
|
|
|
|
displacement = 0;
|
|
|
|
++position;
|
|
|
|
}
|
2011-09-26 15:46:11 +00:00
|
|
|
ret += hist_entry__fprintf(h, max_cols, hists, pair, show_displacement,
|
2012-01-04 14:27:03 +00:00
|
|
|
displacement, total_period, fp);
|
2010-03-12 15:46:48 +00:00
|
|
|
|
|
|
|
if (symbol_conf.use_callchain)
|
2012-01-04 14:27:03 +00:00
|
|
|
ret += hist_entry__fprintf_callchain(h, hists, total_period, fp);
|
2011-09-26 15:46:11 +00:00
|
|
|
if (max_rows && ++nr_rows >= max_rows)
|
|
|
|
goto out;
|
|
|
|
|
2010-03-24 19:40:17 +00:00
|
|
|
if (h->ms.map == NULL && verbose > 1) {
|
2010-03-09 18:58:17 +00:00
|
|
|
__map_groups__fprintf_maps(&h->thread->mg,
|
2010-03-26 15:11:06 +00:00
|
|
|
MAP__FUNCTION, verbose, fp);
|
2010-03-09 18:58:17 +00:00
|
|
|
fprintf(fp, "%.10s end\n", graph_dotted_line);
|
|
|
|
}
|
2009-12-16 14:27:09 +00:00
|
|
|
}
|
2011-09-26 15:46:11 +00:00
|
|
|
out:
|
2009-12-16 14:27:09 +00:00
|
|
|
free(rem_sq_bracket);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2010-05-11 14:10:15 +00:00
|
|
|
|
2010-07-21 20:58:25 +00:00
|
|
|
/*
|
|
|
|
* See hists__fprintf to match the column widths
|
|
|
|
*/
|
2011-09-26 15:33:28 +00:00
|
|
|
unsigned int hists__sort_list_width(struct hists *hists)
|
2010-07-21 20:58:25 +00:00
|
|
|
{
|
|
|
|
struct sort_entry *se;
|
|
|
|
int ret = 9; /* total % */
|
|
|
|
|
|
|
|
if (symbol_conf.show_cpu_utilization) {
|
|
|
|
ret += 7; /* count_sys % */
|
|
|
|
ret += 6; /* count_us % */
|
|
|
|
if (perf_guest) {
|
|
|
|
ret += 13; /* count_guest_sys % */
|
|
|
|
ret += 12; /* count_guest_us % */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (symbol_conf.show_nr_samples)
|
|
|
|
ret += 11;
|
|
|
|
|
2011-10-05 19:10:06 +00:00
|
|
|
if (symbol_conf.show_total_period)
|
|
|
|
ret += 13;
|
|
|
|
|
2010-07-21 20:58:25 +00:00
|
|
|
list_for_each_entry(se, &hist_entry__sort_list, list)
|
|
|
|
if (!se->elide)
|
2011-09-26 15:33:28 +00:00
|
|
|
ret += 2 + hists__col_len(hists, se->se_width_idx);
|
2010-07-21 20:58:25 +00:00
|
|
|
|
2010-08-05 22:15:48 +00:00
|
|
|
if (verbose) /* Addr + origin */
|
|
|
|
ret += 3 + BITS_PER_LONG / 4;
|
|
|
|
|
2010-07-21 20:58:25 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h,
|
2010-07-16 15:35:07 +00:00
|
|
|
enum hist_filter filter)
|
|
|
|
{
|
|
|
|
h->filtered &= ~(1 << filter);
|
|
|
|
if (h->filtered)
|
|
|
|
return;
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
++hists->nr_entries;
|
2010-07-26 20:13:40 +00:00
|
|
|
if (h->ms.unfolded)
|
2011-09-26 15:33:28 +00:00
|
|
|
hists->nr_entries += h->nr_rows;
|
2010-07-26 20:13:40 +00:00
|
|
|
h->row_offset = 0;
|
2011-09-26 15:33:28 +00:00
|
|
|
hists->stats.total_period += h->period;
|
|
|
|
hists->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
|
2010-07-16 15:35:07 +00:00
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
hists__calc_col_len(hists, h);
|
2010-07-16 15:35:07 +00:00
|
|
|
}
|
|
|
|
|
2011-10-19 15:09:10 +00:00
|
|
|
|
|
|
|
static bool hists__filter_entry_by_dso(struct hists *hists,
|
|
|
|
struct hist_entry *he)
|
|
|
|
{
|
|
|
|
if (hists->dso_filter != NULL &&
|
|
|
|
(he->ms.map == NULL || he->ms.map->dso != hists->dso_filter)) {
|
|
|
|
he->filtered |= (1 << HIST_FILTER__DSO);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-10-18 21:07:34 +00:00
|
|
|
void hists__filter_by_dso(struct hists *hists)
|
2010-05-11 14:10:15 +00:00
|
|
|
{
|
|
|
|
struct rb_node *nd;
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
hists->nr_entries = hists->stats.total_period = 0;
|
|
|
|
hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
|
|
|
|
hists__reset_col_len(hists);
|
2010-05-11 14:10:15 +00:00
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
|
2010-05-11 14:10:15 +00:00
|
|
|
struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
|
|
|
|
|
|
|
|
if (symbol_conf.exclude_other && !h->parent)
|
|
|
|
continue;
|
|
|
|
|
2011-10-19 15:09:10 +00:00
|
|
|
if (hists__filter_entry_by_dso(hists, h))
|
2010-05-11 14:10:15 +00:00
|
|
|
continue;
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
hists__remove_entry_filter(hists, h, HIST_FILTER__DSO);
|
2010-05-11 14:10:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-19 15:09:10 +00:00
|
|
|
static bool hists__filter_entry_by_thread(struct hists *hists,
|
|
|
|
struct hist_entry *he)
|
|
|
|
{
|
|
|
|
if (hists->thread_filter != NULL &&
|
|
|
|
he->thread != hists->thread_filter) {
|
|
|
|
he->filtered |= (1 << HIST_FILTER__THREAD);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-10-18 21:07:34 +00:00
|
|
|
void hists__filter_by_thread(struct hists *hists)
|
2010-05-11 14:10:15 +00:00
|
|
|
{
|
|
|
|
struct rb_node *nd;
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
hists->nr_entries = hists->stats.total_period = 0;
|
|
|
|
hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
|
|
|
|
hists__reset_col_len(hists);
|
2010-05-11 14:10:15 +00:00
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
|
2010-05-11 14:10:15 +00:00
|
|
|
struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
|
|
|
|
|
2011-10-19 15:09:10 +00:00
|
|
|
if (hists__filter_entry_by_thread(hists, h))
|
2010-05-11 14:10:15 +00:00
|
|
|
continue;
|
2010-07-16 15:35:07 +00:00
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
hists__remove_entry_filter(hists, h, HIST_FILTER__THREAD);
|
2010-05-11 14:10:15 +00:00
|
|
|
}
|
|
|
|
}
|
2010-05-12 02:18:06 +00:00
|
|
|
|
2012-03-16 08:50:51 +00:00
|
|
|
static bool hists__filter_entry_by_symbol(struct hists *hists,
|
|
|
|
struct hist_entry *he)
|
|
|
|
{
|
|
|
|
if (hists->symbol_filter_str != NULL &&
|
|
|
|
(!he->ms.sym || strstr(he->ms.sym->name,
|
|
|
|
hists->symbol_filter_str) == NULL)) {
|
|
|
|
he->filtered |= (1 << HIST_FILTER__SYMBOL);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void hists__filter_by_symbol(struct hists *hists)
|
|
|
|
{
|
|
|
|
struct rb_node *nd;
|
|
|
|
|
|
|
|
hists->nr_entries = hists->stats.total_period = 0;
|
|
|
|
hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
|
|
|
|
hists__reset_col_len(hists);
|
|
|
|
|
|
|
|
for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
|
|
|
|
struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
|
|
|
|
|
|
|
|
if (hists__filter_entry_by_symbol(hists, h))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
hists__remove_entry_filter(hists, h, HIST_FILTER__SYMBOL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-04 15:43:24 +00:00
|
|
|
int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip)
|
2010-05-12 02:18:06 +00:00
|
|
|
{
|
2011-02-04 15:43:24 +00:00
|
|
|
return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip);
|
2010-05-12 02:18:06 +00:00
|
|
|
}
|
|
|
|
|
2011-02-08 15:27:39 +00:00
|
|
|
int hist_entry__annotate(struct hist_entry *he, size_t privsize)
|
2010-05-12 02:18:06 +00:00
|
|
|
{
|
2011-02-08 15:27:39 +00:00
|
|
|
return symbol__annotate(he->ms.sym, he->ms.map, privsize);
|
2010-05-12 02:18:06 +00:00
|
|
|
}
|
2010-05-14 13:36:42 +00:00
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
void hists__inc_nr_events(struct hists *hists, u32 type)
|
2010-05-14 13:36:42 +00:00
|
|
|
{
|
2011-09-26 15:33:28 +00:00
|
|
|
++hists->stats.nr_events[0];
|
|
|
|
++hists->stats.nr_events[type];
|
2010-05-14 13:36:42 +00:00
|
|
|
}
|
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
size_t hists__fprintf_nr_events(struct hists *hists, FILE *fp)
|
2010-05-14 13:36:42 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
size_t ret = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
|
2011-03-06 00:40:06 +00:00
|
|
|
const char *name;
|
2010-12-07 12:48:42 +00:00
|
|
|
|
2011-09-26 15:33:28 +00:00
|
|
|
if (hists->stats.nr_events[i] == 0)
|
2011-03-06 00:40:06 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
name = perf_event__name(i);
|
2010-12-07 12:48:42 +00:00
|
|
|
if (!strcmp(name, "UNKNOWN"))
|
2010-05-14 13:36:42 +00:00
|
|
|
continue;
|
2010-12-07 12:48:42 +00:00
|
|
|
|
|
|
|
ret += fprintf(fp, "%16s events: %10d\n", name,
|
2011-09-26 15:33:28 +00:00
|
|
|
hists->stats.nr_events[i]);
|
2010-05-14 13:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|