/*
- * kerneltop.c: show top kernel functions - performance counters showcase
-
- Build with:
-
- make -C Documentation/perf_counter/
-
- Sample output:
-
-------------------------------------------------------------------------------
- KernelTop: 2669 irqs/sec [cache-misses/cache-refs], (all, cpu: 2)
-------------------------------------------------------------------------------
-
- weight RIP kernel function
- ______ ________________ _______________
-
- 35.20 - ffffffff804ce74b : skb_copy_and_csum_dev
- 33.00 - ffffffff804cb740 : sock_alloc_send_skb
- 31.26 - ffffffff804ce808 : skb_push
- 22.43 - ffffffff80510004 : tcp_established_options
- 19.00 - ffffffff8027d250 : find_get_page
- 15.76 - ffffffff804e4fc9 : eth_type_trans
- 15.20 - ffffffff804d8baa : dst_release
- 14.86 - ffffffff804cf5d8 : skb_release_head_state
- 14.00 - ffffffff802217d5 : read_hpet
- 12.00 - ffffffff804ffb7f : __ip_local_out
- 11.97 - ffffffff804fc0c8 : ip_local_deliver_finish
- 8.54 - ffffffff805001a3 : ip_queue_xmit
+ * builtin-top.c
+ *
+ * Builtin top command: Display a continuously updated profile of
+ * any workload, CPU or specific PID.
+ *
+ * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
+ *
+ * Improvements and fixes by:
+ *
+ * Arjan van de Ven <arjan@linux.intel.com>
+ * Yanmin Zhang <yanmin.zhang@intel.com>
+ * Wu Fengguang <fengguang.wu@intel.com>
+ * Mike Galbraith <efault@gmx.de>
+ * Paul Mackerras <paulus@samba.org>
+ *
+ * Released under the GPL v2. (and only v2, not any later version)
*/
-
- /*
- * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
- *
- * Improvements and fixes by:
- *
- * Arjan van de Ven <arjan@linux.intel.com>
- * Yanmin Zhang <yanmin.zhang@intel.com>
- * Wu Fengguang <fengguang.wu@intel.com>
- * Mike Galbraith <efault@gmx.de>
- * Paul Mackerras <paulus@samba.org>
- *
- * Released under the GPL v2. (and only v2, not any later version)
- */
+#include "builtin.h"
#include "perf.h"
-#include "builtin.h"
-#include "util/util.h"
+
+#include "util/symbol.h"
+#include "util/color.h"
#include "util/util.h"
+#include "util/rbtree.h"
#include "util/parse-options.h"
#include "util/parse-events.h"
static int event_count[MAX_COUNTERS];
static int fd[MAX_NR_CPUS][MAX_COUNTERS];
-static __u64 count_filter = 100;
+static __u64 count_filter = 5;
+static int print_entries = 15;
-static int target_pid = -1;
+static int target_pid = -1;
static int profile_cpu = -1;
static int nr_cpus = 0;
static unsigned int realtime_prio = 0;
static int group = 0;
static unsigned int page_size;
static unsigned int mmap_pages = 16;
-static int use_mmap = 0;
-static int use_munmap = 0;
static int freq = 0;
static char *sym_filter;
static uint64_t max_ip = -1ll;
struct sym_entry {
- unsigned long long addr;
- char *sym;
+ struct rb_node rb_node;
+ struct list_head node;
unsigned long count[MAX_COUNTERS];
+ unsigned long snap_count;
+ double weight;
int skip;
};
-#define MAX_SYMS 100000
-
-static int sym_table_count;
-
struct sym_entry *sym_filter_entry;
-static struct sym_entry sym_table[MAX_SYMS];
+struct dso *kernel_dso;
+
+/*
+ * Symbols will be added here in record_ip and will get out
+ * after decayed.
+ */
+static LIST_HEAD(active_symbols);
+static pthread_mutex_t active_symbols_lock = PTHREAD_MUTEX_INITIALIZER;
/*
* Ordering weight: count-1 * count-2 * ... / count-n
*/
static double sym_weight(const struct sym_entry *sym)
{
- double weight;
+ double weight = sym->snap_count;
int counter;
- weight = sym->count[0];
-
for (counter = 1; counter < nr_counters-1; counter++)
weight *= sym->count[counter];
return weight;
}
-static int compare(const void *__sym1, const void *__sym2)
+static long events;
+static long userspace_events;
+static const char CONSOLE_CLEAR[] = "\e[H\e[2J";
+
+static void __list_insert_active_sym(struct sym_entry *syme)
{
- const struct sym_entry *sym1 = __sym1, *sym2 = __sym2;
+ list_add(&syme->node, &active_symbols);
+}
- return sym_weight(sym1) < sym_weight(sym2);
+static void list_remove_active_sym(struct sym_entry *syme)
+{
+ pthread_mutex_lock(&active_symbols_lock);
+ list_del_init(&syme->node);
+ pthread_mutex_unlock(&active_symbols_lock);
}
-static long events;
-static long userspace_events;
-static const char CONSOLE_CLEAR[] = "\e[H\e[2J";
+static void rb_insert_active_sym(struct rb_root *tree, struct sym_entry *se)
+{
+ struct rb_node **p = &tree->rb_node;
+ struct rb_node *parent = NULL;
+ struct sym_entry *iter;
-static struct sym_entry tmp[MAX_SYMS];
+ while (*p != NULL) {
+ parent = *p;
+ iter = rb_entry(parent, struct sym_entry, rb_node);
+
+ if (se->weight > iter->weight)
+ p = &(*p)->rb_left;
+ else
+ p = &(*p)->rb_right;
+ }
+
+ rb_link_node(&se->rb_node, parent, p);
+ rb_insert_color(&se->rb_node, tree);
+}
static void print_sym_table(void)
{
- int i, j, active_count, printed;
+ int printed = 0, j;
int counter;
float events_per_sec = events/delay_secs;
float kevents_per_sec = (events-userspace_events)/delay_secs;
float sum_kevents = 0.0;
+ struct sym_entry *syme, *n;
+ struct rb_root tmp = RB_ROOT;
+ struct rb_node *nd;
events = userspace_events = 0;
- /* Iterate over symbol table and copy/tally/decay active symbols. */
- for (i = 0, active_count = 0; i < sym_table_count; i++) {
- if (sym_table[i].count[0]) {
- tmp[active_count++] = sym_table[i];
- sum_kevents += sym_table[i].count[0];
+ /* Sort the active symbols */
+ pthread_mutex_lock(&active_symbols_lock);
+ syme = list_entry(active_symbols.next, struct sym_entry, node);
+ pthread_mutex_unlock(&active_symbols_lock);
+
+ list_for_each_entry_safe_from(syme, n, &active_symbols, node) {
+ syme->snap_count = syme->count[0];
+ if (syme->snap_count != 0) {
+ syme->weight = sym_weight(syme);
+ rb_insert_active_sym(&tmp, syme);
+ sum_kevents += syme->snap_count;
for (j = 0; j < nr_counters; j++)
- sym_table[i].count[j] = zero ? 0 : sym_table[i].count[j] * 7 / 8;
- }
+ syme->count[j] = zero ? 0 : syme->count[j] * 7 / 8;
+ } else
+ list_remove_active_sym(syme);
}
- qsort(tmp, active_count + 1, sizeof(tmp[0]), compare);
-
write(1, CONSOLE_CLEAR, strlen(CONSOLE_CLEAR));
printf(
"------------------------------------------------------------------------------\n");
- printf( " KernelTop:%8.0f irqs/sec kernel:%4.1f%% [",
+ printf( " PerfTop:%8.0f irqs/sec kernel:%4.1f%% [",
events_per_sec,
100.0 - (100.0*((events_per_sec-kevents_per_sec)/events_per_sec)));
" ______ ______ _____ ________________ _______________\n\n"
);
- for (i = 0, printed = 0; i < active_count; i++) {
- float pcnt;
+ for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) {
+ struct sym_entry *syme = rb_entry(nd, struct sym_entry, rb_node);
+ struct symbol *sym = (struct symbol *)(syme + 1);
+ char *color = PERF_COLOR_NORMAL;
+ double pcnt;
+
+ if (++printed > print_entries || syme->snap_count < count_filter)
+ continue;
- if (++printed > 18 || tmp[i].count[0] < count_filter)
- break;
+ pcnt = 100.0 - (100.0 * ((sum_kevents - syme->snap_count) /
+ sum_kevents));
- pcnt = 100.0 - (100.0*((sum_kevents-tmp[i].count[0])/sum_kevents));
+ /*
+ * We color high-overhead entries in red, low-overhead
+ * entries in green - and keep the middle ground normal:
+ */
+ if (pcnt >= 5.0)
+ color = PERF_COLOR_RED;
+ if (pcnt < 0.5)
+ color = PERF_COLOR_GREEN;
if (nr_counters == 1)
- printf("%19.2f - %4.1f%% - %016llx : %s\n",
- sym_weight(tmp + i),
- pcnt, tmp[i].addr, tmp[i].sym);
+ printf("%19.2f - ", syme->weight);
else
- printf("%8.1f %10ld - %4.1f%% - %016llx : %s\n",
- sym_weight(tmp + i),
- tmp[i].count[0],
- pcnt, tmp[i].addr, tmp[i].sym);
+ printf("%8.1f %10ld - ", syme->weight, syme->snap_count);
+
+ color_fprintf(stdout, color, "%4.1f%%", pcnt);
+ printf(" - %016llx : %s\n", sym->start, sym->name);
}
{
static void *display_thread(void *arg)
{
- printf("KernelTop refresh period: %d seconds\n", delay_secs);
+ printf("PerfTop refresh period: %d seconds\n", delay_secs);
while (!sleep(delay_secs))
print_sym_table();
return NULL;
}
-static int read_symbol(FILE *in, struct sym_entry *s)
+static int symbol_filter(struct dso *self, struct symbol *sym)
{
- static int filter_match = 0;
- char *sym, stype;
- char str[500];
- int rc, pos;
-
- rc = fscanf(in, "%llx %c %499s", &s->addr, &stype, str);
- if (rc == EOF)
- return -1;
-
- assert(rc == 3);
-
- /* skip until end of line: */
- pos = strlen(str);
- do {
- rc = fgetc(in);
- if (rc == '\n' || rc == EOF || pos >= 499)
- break;
- str[pos] = rc;
- pos++;
- } while (1);
- str[pos] = 0;
-
- sym = str;
-
- /* Filter out known duplicates and non-text symbols. */
- if (!strcmp(sym, "_text"))
- return 1;
- if (!min_ip && !strcmp(sym, "_stext"))
- return 1;
- if (!strcmp(sym, "_etext") || !strcmp(sym, "_sinittext"))
- return 1;
- if (stype != 'T' && stype != 't')
- return 1;
- if (!strncmp("init_module", sym, 11) || !strncmp("cleanup_module", sym, 14))
- return 1;
- if (strstr(sym, "_text_start") || strstr(sym, "_text_end"))
+ static int filter_match;
+ struct sym_entry *syme;
+ const char *name = sym->name;
+
+ if (!strcmp(name, "_text") ||
+ !strcmp(name, "_etext") ||
+ !strcmp(name, "_sinittext") ||
+ !strncmp("init_module", name, 11) ||
+ !strncmp("cleanup_module", name, 14) ||
+ strstr(name, "_text_start") ||
+ strstr(name, "_text_end"))
return 1;
- s->sym = malloc(strlen(str)+1);
- assert(s->sym);
-
- strcpy((char *)s->sym, str);
- s->skip = 0;
-
+ syme = dso__sym_priv(self, sym);
/* Tag events to be skipped. */
- if (!strcmp("default_idle", s->sym) || !strcmp("cpu_idle", s->sym))
- s->skip = 1;
- else if (!strcmp("enter_idle", s->sym) || !strcmp("exit_idle", s->sym))
- s->skip = 1;
- else if (!strcmp("mwait_idle", s->sym))
- s->skip = 1;
+ if (!strcmp("default_idle", name) ||
+ !strcmp("cpu_idle", name) ||
+ !strcmp("enter_idle", name) ||
+ !strcmp("exit_idle", name) ||
+ !strcmp("mwait_idle", name))
+ syme->skip = 1;
if (filter_match == 1) {
- filter_end = s->addr;
+ filter_end = sym->start;
filter_match = -1;
if (filter_end - filter_start > 10000) {
- printf("hm, too large filter symbol <%s> - skipping.\n",
+ fprintf(stderr,
+ "hm, too large filter symbol <%s> - skipping.\n",
sym_filter);
- printf("symbol filter start: %016lx\n", filter_start);
- printf(" end: %016lx\n", filter_end);
+ fprintf(stderr, "symbol filter start: %016lx\n",
+ filter_start);
+ fprintf(stderr, " end: %016lx\n",
+ filter_end);
filter_end = filter_start = 0;
sym_filter = NULL;
sleep(1);
}
}
- if (filter_match == 0 && sym_filter && !strcmp(s->sym, sym_filter)) {
+
+ if (filter_match == 0 && sym_filter && !strcmp(name, sym_filter)) {
filter_match = 1;
- filter_start = s->addr;
+ filter_start = sym->start;
}
- return 0;
-}
-static int compare_addr(const void *__sym1, const void *__sym2)
-{
- const struct sym_entry *sym1 = __sym1, *sym2 = __sym2;
-
- return sym1->addr > sym2->addr;
+ return 0;
}
-static void sort_symbol_table(void)
+static int parse_symbols(void)
{
- int i, dups;
-
- do {
- qsort(sym_table, sym_table_count, sizeof(sym_table[0]), compare_addr);
- for (i = 0, dups = 0; i < sym_table_count; i++) {
- if (sym_table[i].addr == sym_table[i+1].addr) {
- sym_table[i+1].addr = -1ll;
- dups++;
- }
- }
- sym_table_count -= dups;
- } while(dups);
-}
+ struct rb_node *node;
+ struct symbol *sym;
-static void parse_symbols(void)
-{
- struct sym_entry *last;
+ kernel_dso = dso__new("[kernel]", sizeof(struct sym_entry));
+ if (kernel_dso == NULL)
+ return -1;
- FILE *kallsyms = fopen("/proc/kallsyms", "r");
+ if (dso__load_kernel(kernel_dso, NULL, symbol_filter, 1) != 0)
+ goto out_delete_dso;
- if (!kallsyms) {
- printf("Could not open /proc/kallsyms - no CONFIG_KALLSYMS_ALL=y?\n");
- exit(-1);
- }
+ node = rb_first(&kernel_dso->syms);
+ sym = rb_entry(node, struct symbol, rb_node);
+ min_ip = sym->start;
- while (!feof(kallsyms)) {
- if (read_symbol(kallsyms, &sym_table[sym_table_count]) == 0) {
- sym_table_count++;
- assert(sym_table_count <= MAX_SYMS);
- }
- }
+ node = rb_last(&kernel_dso->syms);
+ sym = rb_entry(node, struct symbol, rb_node);
+ max_ip = sym->end;
- sort_symbol_table();
- min_ip = sym_table[0].addr;
- max_ip = sym_table[sym_table_count-1].addr;
- last = sym_table + sym_table_count++;
+ if (dump_symtab)
+ dso__fprintf(kernel_dso, stderr);
- last->addr = -1ll;
- last->sym = "<end>";
-
- if (filter_end) {
- int count;
- for (count=0; count < sym_table_count; count ++) {
- if (!strcmp(sym_table[count].sym, sym_filter)) {
- sym_filter_entry = &sym_table[count];
- break;
- }
- }
- }
- if (dump_symtab) {
- int i;
+ return 0;
- for (i = 0; i < sym_table_count; i++)
- fprintf(stderr, "%llx %s\n",
- sym_table[i].addr, sym_table[i].sym);
- }
+out_delete_dso:
+ dso__delete(kernel_dso);
+ kernel_dso = NULL;
+ return -1;
}
#define TRACE_COUNT 3
*/
static void record_ip(uint64_t ip, int counter)
{
- int left_idx, middle_idx, right_idx, idx;
- unsigned long left, middle, right;
-
- left_idx = 0;
- right_idx = sym_table_count-1;
- assert(ip <= max_ip && ip >= min_ip);
-
- while (left_idx + 1 < right_idx) {
- middle_idx = (left_idx + right_idx) / 2;
-
- left = sym_table[ left_idx].addr;
- middle = sym_table[middle_idx].addr;
- right = sym_table[ right_idx].addr;
-
- if (!(left <= middle && middle <= right)) {
- printf("%016lx...\n%016lx...\n%016lx\n", left, middle, right);
- printf("%d %d %d\n", left_idx, middle_idx, right_idx);
- }
- assert(left <= middle && middle <= right);
- if (!(left <= ip && ip <= right)) {
- printf(" left: %016lx\n", left);
- printf(" ip: %016lx\n", (unsigned long)ip);
- printf("right: %016lx\n", right);
+ struct symbol *sym = dso__find_symbol(kernel_dso, ip);
+
+ if (sym != NULL) {
+ struct sym_entry *syme = dso__sym_priv(kernel_dso, sym);
+
+ if (!syme->skip) {
+ syme->count[counter]++;
+ pthread_mutex_lock(&active_symbols_lock);
+ if (list_empty(&syme->node) || !syme->node.next)
+ __list_insert_active_sym(syme);
+ pthread_mutex_unlock(&active_symbols_lock);
+ return;
}
- assert(left <= ip && ip <= right);
- /*
- * [ left .... target .... middle .... right ]
- * => right := middle
- */
- if (ip < middle) {
- right_idx = middle_idx;
- continue;
- }
- /*
- * [ left .... middle ... target ... right ]
- * => left := middle
- */
- left_idx = middle_idx;
}
- idx = left_idx;
-
- if (!sym_table[idx].skip)
- sym_table[idx].count[counter]++;
- else events--;
+ events--;
}
static void process_event(uint64_t ip, int counter)
old += size;
if (event->header.misc & PERF_EVENT_MISC_OVERFLOW) {
- if (event->header.type & PERF_RECORD_IP)
+ if (event->header.type & PERF_SAMPLE_IP)
process_event(event->ip.ip, md->counter);
- } else {
- switch (event->header.type) {
- case PERF_EVENT_MMAP:
- case PERF_EVENT_MUNMAP:
- printf("%s: %Lu %Lu %Lu %s\n",
- event->header.type == PERF_EVENT_MMAP
- ? "mmap" : "munmap",
- event->mmap.start,
- event->mmap.len,
- event->mmap.pgoff,
- event->mmap.filename);
- break;
- }
}
}
static int __cmd_top(void)
{
- struct perf_counter_hw_event hw_event;
+ struct perf_counter_attr attr;
pthread_t thread;
int i, counter, group_fd, nr_poll = 0;
unsigned int cpu;
if (target_pid == -1 && profile_cpu == -1)
cpu = i;
- memset(&hw_event, 0, sizeof(hw_event));
- hw_event.config = event_id[counter];
- hw_event.irq_period = event_count[counter];
- hw_event.record_type = PERF_RECORD_IP | PERF_RECORD_TID;
- hw_event.nmi = 1;
- hw_event.mmap = use_mmap;
- hw_event.munmap = use_munmap;
- hw_event.freq = freq;
+ memset(&attr, 0, sizeof(attr));
+ attr.config = event_id[counter];
+ attr.sample_period = event_count[counter];
+ attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID;
+ attr.freq = freq;
- fd[i][counter] = sys_perf_counter_open(&hw_event, target_pid, cpu, group_fd, 0);
+ fd[i][counter] = sys_perf_counter_open(&attr, target_pid, cpu, group_fd, 0);
if (fd[i][counter] < 0) {
int err = errno;
- printf("kerneltop error: syscall returned with %d (%s)\n",
+
+ error("syscall returned with %d (%s)\n",
fd[i][counter], strerror(err));
if (err == EPERM)
printf("Are you root?\n");
mmap_array[i][counter].mask = mmap_pages*page_size - 1;
mmap_array[i][counter].base = mmap(NULL, (mmap_pages+1)*page_size,
PROT_READ, MAP_SHARED, fd[i][counter], 0);
- if (mmap_array[i][counter].base == MAP_FAILED) {
- printf("kerneltop error: failed to mmap with %d (%s)\n",
- errno, strerror(errno));
- exit(-1);
- }
+ if (mmap_array[i][counter].base == MAP_FAILED)
+ die("failed to mmap with %d (%s)\n", errno, strerror(errno));
}
}
"number of seconds to delay between refreshes"),
OPT_BOOLEAN('D', "dump-symtab", &dump_symtab,
"dump the symbol table used for profiling"),
- OPT_INTEGER('f', "--count-filter", &count_filter,
+ OPT_INTEGER('f', "count-filter", &count_filter,
"only display functions with more events than this"),
OPT_BOOLEAN('g', "group", &group,
"put the counters into a counter group"),
"only display symbols matchig this pattern"),
OPT_BOOLEAN('z', "zero", &group,
"zero history across updates"),
- OPT_BOOLEAN('M', "use-mmap", &use_mmap,
- "track mmap events"),
- OPT_BOOLEAN('U', "use-munmap", &use_munmap,
- "track munmap events"),
- OPT_INTEGER('F', "--freq", &freq,
+ OPT_INTEGER('F', "freq", &freq,
"profile at this frequency"),
+ OPT_INTEGER('E', "entries", &print_entries,
+ "display this many functions"),
OPT_END()
};
projects / deliverable / linux.git / blobdiff