adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 11:46:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

perf_counter: tools: report: Rework histogram code

Browse source 
In preparation for configurable sorting, rework the histgram code a bit.

Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Corey Ashford <cjashfor@linux.vnet.ibm.com>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: John Kacur <jkacur@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20090527182100.796410098@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Peter Zijlstra 2009-05-27 20:20:24 +02:00 committed by Ingo Molnar
parent 450aaa2b2a
commit e7fb08b1d0
1 changed files with 144 additions and 152 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

296
Documentation/perf_counter/builtin-report.c
View file

@ -597,71 +597,9 @@ struct thread;
static const char *thread__name(struct thread *self, char *bf, size_t size); static const char *thread__name(struct thread *self, char *bf, size_t size);
struct symhist {
struct rb_node rb_node;
struct dso *dso;
struct symbol *sym;
struct thread *thread;
uint64_t ip;
uint32_t count;
char level;
};
static struct symhist *symhist__new(struct symbol *sym, uint64_t ip,
struct thread *thread, struct dso *dso,
char level)
{
struct symhist *self = malloc(sizeof(*self));
if (self != NULL) {
self->sym = sym;
self->thread = thread;
self->ip = ip;
self->dso = dso;
self->level = level;
self->count = 1;
}
return self;
}
static void symhist__inc(struct symhist *self)
{
++self->count;
}
static size_t
symhist__fprintf(struct symhist *self, uint64_t total_samples, FILE *fp)
{
char bf[32];
size_t ret;
if (total_samples)
ret = fprintf(fp, "%5.2f%% ", (self->count * 100.0) / total_samples);
else
ret = fprintf(fp, "%12d ", self->count);
ret += fprintf(fp, "%14s [%c] ",
thread__name(self->thread, bf, sizeof(bf)),
self->level);
if (verbose)
ret += fprintf(fp, "%#018llx ", (unsigned long long)self->ip);
if (self->level != '.')
ret += fprintf(fp, "%s\n",
self->sym ? self->sym->name : "<unknown>");
else
ret += fprintf(fp, "%s: %s\n",
self->dso ? self->dso->name : "<unknown>",
self->sym ? self->sym->name : "<unknown>");
return ret;
}
struct thread { struct thread {
struct rb_node rb_node; struct rb_node rb_node;
struct list_head maps; struct list_head maps;
struct rb_root symhists;
pid_t pid; pid_t pid;
char *comm; char *comm;
}; };
@ -683,67 +621,17 @@ static struct thread *thread__new(pid_t pid)
self->pid = pid; self->pid = pid;
self->comm = NULL; self->comm = NULL;
INIT_LIST_HEAD(&self->maps); INIT_LIST_HEAD(&self->maps);
self->symhists = RB_ROOT;
} }
return self; return self;
} }
static int thread__symbol_incnew(struct thread *self, struct symbol *sym,
uint64_t ip, struct dso *dso, char level)
{
struct rb_node **p = &self->symhists.rb_node;
struct rb_node *parent = NULL;
struct symhist *sh;
while (*p != NULL) {
uint64_t start;
parent = *p;
sh = rb_entry(parent, struct symhist, rb_node);
if (sh->sym == sym || ip == sh->ip) {
symhist__inc(sh);
return 0;
}
/* Handle unresolved symbols too */
start = !sh->sym ? sh->ip : sh->sym->start;
if (ip < start)
p = &(*p)->rb_left;
else
p = &(*p)->rb_right;
}
sh = symhist__new(sym, ip, self, dso, level);
if (sh == NULL)
return -ENOMEM;
rb_link_node(&sh->rb_node, parent, p);
rb_insert_color(&sh->rb_node, &self->symhists);
return 0;
}
static int thread__set_comm(struct thread *self, const char *comm) static int thread__set_comm(struct thread *self, const char *comm)
{ {
self->comm = strdup(comm); self->comm = strdup(comm);
return self->comm ? 0 : -ENOMEM; return self->comm ? 0 : -ENOMEM;
} }
static size_t thread__fprintf(struct thread *self, FILE *fp)
{
int ret = fprintf(fp, "thread: %d %s\n", self->pid, self->comm);
struct rb_node *nd;
for (nd = rb_first(&self->symhists); nd; nd = rb_next(nd)) {
struct symhist *pos = rb_entry(nd, struct symhist, rb_node);
ret += symhist__fprintf(pos, 0, fp);
}
return ret;
}
static struct rb_root threads; static struct rb_root threads;
static struct thread *threads__findnew(pid_t pid) static struct thread *threads__findnew(pid_t pid)
@ -792,70 +680,172 @@ static struct map *thread__find_map(struct thread *self, uint64_t ip)
return NULL; return NULL;
} }
static void threads__fprintf(FILE *fp) /*
* histogram, sorted on item, collects counts
*/
static struct rb_root hist;
struct hist_entry {
struct rb_node rb_node;
struct thread *thread;
struct map *map;
struct dso *dso;
struct symbol *sym;
uint64_t ip;
char level;
uint32_t count;
};
static int64_t
hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
{ {
struct rb_node *nd; uint64_t ip_l, ip_r;
for (nd = rb_first(&threads); nd; nd = rb_next(nd)) { int cmp = right->thread->pid - left->thread->pid;
struct thread *pos = rb_entry(nd, struct thread, rb_node);
thread__fprintf(pos, fp); if (cmp)
} return cmp;
if (left->sym == right->sym)
return 0;
ip_l = left->sym ? left->sym->start : left->ip;
ip_r = right->sym ? right->sym->start : right->ip;
return (int64_t)(ip_r - ip_l);
} }
static struct rb_root global_symhists; static int
hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
static void threads__insert_symhist(struct symhist *sh) struct symbol *sym, uint64_t ip, char level)
{ {
struct rb_node **p = &global_symhists.rb_node; struct rb_node **p = &hist.rb_node;
struct rb_node *parent = NULL; struct rb_node *parent = NULL;
struct symhist *iter; struct hist_entry *he;
struct hist_entry entry = {
.thread = thread,
.map = map,
.dso = dso,
.sym = sym,
.ip = ip,
.level = level,
.count = 1,
};
int cmp;
while (*p != NULL) { while (*p != NULL) {
parent = *p; parent = *p;
iter = rb_entry(parent, struct symhist, rb_node); he = rb_entry(parent, struct hist_entry, rb_node);
/* Reverse order */ cmp = hist_entry__cmp(&entry, he);
if (sh->count > iter->count)
if (!cmp) {
he->count++;
return 0;
}
if (cmp < 0)
p = &(*p)->rb_left; p = &(*p)->rb_left;
else else
p = &(*p)->rb_right; p = &(*p)->rb_right;
} }
rb_link_node(&sh->rb_node, parent, p); he = malloc(sizeof(*he));
rb_insert_color(&sh->rb_node, &global_symhists); if (!he)
return -ENOMEM;
*he = entry;
rb_link_node(&he->rb_node, parent, p);
rb_insert_color(&he->rb_node, &hist);
return 0;
} }
static void threads__sort_symhists(void) static size_t
hist_entry__fprintf(FILE *fp, struct hist_entry *self, uint64_t total_samples)
{ {
struct rb_node *nd; char bf[32];
size_t ret;
for (nd = rb_first(&threads); nd; nd = rb_next(nd)) { if (total_samples) {
struct thread *thread = rb_entry(nd, struct thread, rb_node); ret = fprintf(fp, "%5.2f%% ",
struct rb_node *next = rb_first(&thread->symhists); (self->count * 100.0) / total_samples);
} else
ret = fprintf(fp, "%12d ", self->count);
while (next) { ret += fprintf(fp, "%14s [%c] ",
struct symhist *n = rb_entry(next, struct symhist, thread__name(self->thread, bf, sizeof(bf)),
rb_node); self->level);
next = rb_next(&n->rb_node);
rb_erase(&n->rb_node, &thread->symhists);
threads__insert_symhist(n);
}
if (verbose)
ret += fprintf(fp, "%#018llx ", (unsigned long long)self->ip);
if (self->level != '.')
ret += fprintf(fp, "%s\n",
self->sym ? self->sym->name : "<unknown>");
else
ret += fprintf(fp, "%s: %s\n",
self->dso ? self->dso->name : "<unknown>",
self->sym ? self->sym->name : "<unknown>");
return ret;
}
/*
* reverse the map, sort on count.
*/
static struct rb_root output_hists;
static void output__insert_entry(struct hist_entry *he)
{
struct rb_node **p = &output_hists.rb_node;
struct rb_node *parent = NULL;
struct hist_entry *iter;
while (*p != NULL) {
parent = *p;
iter = rb_entry(parent, struct hist_entry, rb_node);
if (he->count > iter->count)
p = &(*p)->rb_left;
else
p = &(*p)->rb_right;
}
rb_link_node(&he->rb_node, parent, p);
rb_insert_color(&he->rb_node, &output_hists);
}
static void output__resort(void)
{
struct rb_node *next = rb_first(&hist);
struct hist_entry *n;
while (next) {
n = rb_entry(next, struct hist_entry, rb_node);
next = rb_next(&n->rb_node);
rb_erase(&n->rb_node, &hist);
output__insert_entry(n);
} }
} }
static size_t threads__symhists_fprintf(uint64_t total_samples, FILE *fp) static size_t output__fprintf(FILE *fp, uint64_t total_samples)
{ {
struct hist_entry *pos;
struct rb_node *nd; struct rb_node *nd;
size_t ret = 0; size_t ret = 0;
for (nd = rb_first(&global_symhists); nd; nd = rb_next(nd)) { for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
struct symhist *pos = rb_entry(nd, struct symhist, rb_node); pos = rb_entry(nd, struct hist_entry, rb_node);
ret += symhist__fprintf(pos, total_samples, fp); ret += hist_entry__fprintf(fp, pos, total_samples);
} }
return ret; return ret;
} }
static int __cmd_report(void) static int __cmd_report(void)
{ {
unsigned long offset = 0; unsigned long offset = 0;
@ -926,6 +916,7 @@ more:
struct dso *dso = NULL; struct dso *dso = NULL;
struct thread *thread = threads__findnew(event->ip.pid); struct thread *thread = threads__findnew(event->ip.pid);
uint64_t ip = event->ip.ip; uint64_t ip = event->ip.ip;
struct map *map = NULL;
if (dump_trace) { if (dump_trace) {
fprintf(stderr, "%p [%p]: PERF_EVENT (IP, %d): %d: %p\n", fprintf(stderr, "%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
@ -945,9 +936,10 @@ more:
if (event->header.misc & PERF_EVENT_MISC_KERNEL) { if (event->header.misc & PERF_EVENT_MISC_KERNEL) {
show = SHOW_KERNEL; show = SHOW_KERNEL;
level = 'k'; level = 'k';
dso = kernel_dso; dso = kernel_dso;
} else if (event->header.misc & PERF_EVENT_MISC_USER) { } else if (event->header.misc & PERF_EVENT_MISC_USER) {
struct map *map;
show = SHOW_USER; show = SHOW_USER;
level = '.'; level = '.';
@ -957,6 +949,7 @@ more:
dso = map->dso; dso = map->dso;
ip -= map->start + map->pgoff; ip -= map->start + map->pgoff;
} }
} else { } else {
show = SHOW_HV; show = SHOW_HV;
level = 'H'; level = 'H';
@ -965,8 +958,9 @@ more:
if (show & show_mask) { if (show & show_mask) {
struct symbol *sym = dso__find_symbol(dso, ip); struct symbol *sym = dso__find_symbol(dso, ip);
if (thread__symbol_incnew(thread, sym, ip, dso, level)) { if (hist_entry__add(thread, map, dso, sym, ip, level)) {
fprintf(stderr, "problem incrementing symbol count, bailing out\n"); fprintf(stderr,
"problem incrementing symbol count, bailing out\n");
goto done; goto done;
} }
} }
@ -1050,13 +1044,11 @@ done:
return 0; return 0;
} }
if (verbose >= 2) { if (verbose >= 2)
dsos__fprintf(stdout); dsos__fprintf(stdout);
threads__fprintf(stdout);
}
threads__sort_symhists(); output__resort();
threads__symhists_fprintf(total, stdout); output__fprintf(stdout, total);
return rc; return rc;
} }