2 * kerneltop.c: show top kernel functions - performance counters showcase
6 make -C Documentation/perf_counter/
10 ------------------------------------------------------------------------------
11 KernelTop: 2669 irqs/sec [cache-misses/cache-refs], (all, cpu: 2)
12 ------------------------------------------------------------------------------
14 weight RIP kernel function
15 ______ ________________ _______________
17 35.20 - ffffffff804ce74b : skb_copy_and_csum_dev
18 33.00 - ffffffff804cb740 : sock_alloc_send_skb
19 31.26 - ffffffff804ce808 : skb_push
20 22.43 - ffffffff80510004 : tcp_established_options
21 19.00 - ffffffff8027d250 : find_get_page
22 15.76 - ffffffff804e4fc9 : eth_type_trans
23 15.20 - ffffffff804d8baa : dst_release
24 14.86 - ffffffff804cf5d8 : skb_release_head_state
25 14.00 - ffffffff802217d5 : read_hpet
26 12.00 - ffffffff804ffb7f : __ip_local_out
27 11.97 - ffffffff804fc0c8 : ip_local_deliver_finish
28 8.54 - ffffffff805001a3 : ip_queue_xmit
32 * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
34 * Improvements and fixes by:
36 * Arjan van de Ven <arjan@linux.intel.com>
37 * Yanmin Zhang <yanmin.zhang@intel.com>
38 * Wu Fengguang <fengguang.wu@intel.com>
39 * Mike Galbraith <efault@gmx.de>
40 * Paul Mackerras <paulus@samba.org>
42 * Released under the GPL v2. (and only v2, not any later version)
47 #include "util/symbol.h"
48 #include "util/util.h"
49 #include "util/rbtree.h"
50 #include "util/parse-options.h"
51 #include "util/parse-events.h"
63 #include <sys/syscall.h>
64 #include <sys/ioctl.h>
66 #include <sys/prctl.h>
71 #include <linux/unistd.h>
72 #include <linux/types.h>
74 static int system_wide
= 0;
76 static __u64 default_event_id
[MAX_COUNTERS
] = {
77 EID(PERF_TYPE_SOFTWARE
, PERF_COUNT_TASK_CLOCK
),
78 EID(PERF_TYPE_SOFTWARE
, PERF_COUNT_CONTEXT_SWITCHES
),
79 EID(PERF_TYPE_SOFTWARE
, PERF_COUNT_CPU_MIGRATIONS
),
80 EID(PERF_TYPE_SOFTWARE
, PERF_COUNT_PAGE_FAULTS
),
82 EID(PERF_TYPE_HARDWARE
, PERF_COUNT_CPU_CYCLES
),
83 EID(PERF_TYPE_HARDWARE
, PERF_COUNT_INSTRUCTIONS
),
84 EID(PERF_TYPE_HARDWARE
, PERF_COUNT_CACHE_REFERENCES
),
85 EID(PERF_TYPE_HARDWARE
, PERF_COUNT_CACHE_MISSES
),
87 static int default_interval
= 100000;
88 static int event_count
[MAX_COUNTERS
];
89 static int fd
[MAX_NR_CPUS
][MAX_COUNTERS
];
91 static __u64 count_filter
= 100;
93 static int target_pid
= -1;
94 static int profile_cpu
= -1;
95 static int nr_cpus
= 0;
96 static unsigned int realtime_prio
= 0;
98 static unsigned int page_size
;
99 static unsigned int mmap_pages
= 16;
100 static int use_mmap
= 0;
101 static int use_munmap
= 0;
104 static char *sym_filter
;
105 static unsigned long filter_start
;
106 static unsigned long filter_end
;
108 static int delay_secs
= 2;
110 static int dump_symtab
;
112 static const unsigned int default_count
[] = {
125 static uint64_t min_ip
;
126 static uint64_t max_ip
= -1ll;
129 struct rb_node rb_node
;
130 struct list_head node
;
131 unsigned long count
[MAX_COUNTERS
];
132 unsigned long snap_count
;
137 struct sym_entry
*sym_filter_entry
;
139 struct dso
*kernel_dso
;
142 * Symbols will be added here in record_ip and will get out
145 static LIST_HEAD(active_symbols
);
146 static pthread_mutex_t active_symbols_lock
= PTHREAD_MUTEX_INITIALIZER
;
149 * Ordering weight: count-1 * count-2 * ... / count-n
151 static double sym_weight(const struct sym_entry
*sym
)
153 double weight
= sym
->snap_count
;
156 for (counter
= 1; counter
< nr_counters
-1; counter
++)
157 weight
*= sym
->count
[counter
];
159 weight
/= (sym
->count
[counter
] + 1);
165 static long userspace_events
;
166 static const char CONSOLE_CLEAR
[] = "\e[H\e[2J";
168 static void __list_insert_active_sym(struct sym_entry
*syme
)
170 list_add(&syme
->node
, &active_symbols
);
173 static void list_remove_active_sym(struct sym_entry
*syme
)
175 pthread_mutex_lock(&active_symbols_lock
);
176 list_del_init(&syme
->node
);
177 pthread_mutex_unlock(&active_symbols_lock
);
180 static void rb_insert_active_sym(struct rb_root
*tree
, struct sym_entry
*se
)
182 struct rb_node
**p
= &tree
->rb_node
;
183 struct rb_node
*parent
= NULL
;
184 struct sym_entry
*iter
;
188 iter
= rb_entry(parent
, struct sym_entry
, rb_node
);
190 if (se
->weight
> iter
->weight
)
196 rb_link_node(&se
->rb_node
, parent
, p
);
197 rb_insert_color(&se
->rb_node
, tree
);
200 static void print_sym_table(void)
204 float events_per_sec
= events
/delay_secs
;
205 float kevents_per_sec
= (events
-userspace_events
)/delay_secs
;
206 float sum_kevents
= 0.0;
207 struct sym_entry
*syme
, *n
;
208 struct rb_root tmp
= RB_ROOT
;
211 events
= userspace_events
= 0;
213 /* Sort the active symbols */
214 pthread_mutex_lock(&active_symbols_lock
);
215 syme
= list_entry(active_symbols
.next
, struct sym_entry
, node
);
216 pthread_mutex_unlock(&active_symbols_lock
);
218 list_for_each_entry_safe_from(syme
, n
, &active_symbols
, node
) {
219 syme
->snap_count
= syme
->count
[0];
220 if (syme
->snap_count
!= 0) {
221 syme
->weight
= sym_weight(syme
);
222 rb_insert_active_sym(&tmp
, syme
);
223 sum_kevents
+= syme
->snap_count
;
225 for (j
= 0; j
< nr_counters
; j
++)
226 syme
->count
[j
] = zero
? 0 : syme
->count
[j
] * 7 / 8;
228 list_remove_active_sym(syme
);
231 write(1, CONSOLE_CLEAR
, strlen(CONSOLE_CLEAR
));
234 "------------------------------------------------------------------------------\n");
235 printf( " KernelTop:%8.0f irqs/sec kernel:%4.1f%% [",
237 100.0 - (100.0*((events_per_sec
-kevents_per_sec
)/events_per_sec
)));
239 if (nr_counters
== 1)
240 printf("%d ", event_count
[0]);
242 for (counter
= 0; counter
< nr_counters
; counter
++) {
246 printf("%s", event_name(counter
));
251 if (target_pid
!= -1)
252 printf(" (target_pid: %d", target_pid
);
256 if (profile_cpu
!= -1)
257 printf(", cpu: %d)\n", profile_cpu
);
259 if (target_pid
!= -1)
262 printf(", %d CPUs)\n", nr_cpus
);
265 printf("------------------------------------------------------------------------------\n\n");
267 if (nr_counters
== 1)
268 printf(" events pcnt");
270 printf(" weight events pcnt");
272 printf(" RIP kernel function\n"
273 " ______ ______ _____ ________________ _______________\n\n"
276 for (nd
= rb_first(&tmp
); nd
; nd
= rb_next(nd
)) {
277 struct sym_entry
*syme
= rb_entry(nd
, struct sym_entry
, rb_node
);
278 struct symbol
*sym
= (struct symbol
*)(syme
+ 1);
281 if (++printed
> 18 || syme
->snap_count
< count_filter
)
284 pcnt
= 100.0 - (100.0 * ((sum_kevents
- syme
->snap_count
) /
287 if (nr_counters
== 1)
288 printf("%19.2f - %4.1f%% - %016llx : %s\n",
289 syme
->weight
, pcnt
, sym
->start
, sym
->name
);
291 printf("%8.1f %10ld - %4.1f%% - %016llx : %s\n",
292 syme
->weight
, syme
->snap_count
,
293 pcnt
, sym
->start
, sym
->name
);
297 struct pollfd stdin_poll
= { .fd
= 0, .events
= POLLIN
};
299 if (poll(&stdin_poll
, 1, 0) == 1) {
300 printf("key pressed - exiting.\n");
306 static void *display_thread(void *arg
)
308 printf("KernelTop refresh period: %d seconds\n", delay_secs
);
310 while (!sleep(delay_secs
))
316 static int symbol_filter(struct dso
*self
, struct symbol
*sym
)
318 static int filter_match
;
319 struct sym_entry
*syme
;
320 const char *name
= sym
->name
;
322 if (!strcmp(name
, "_text") ||
323 !strcmp(name
, "_etext") ||
324 !strcmp(name
, "_sinittext") ||
325 !strncmp("init_module", name
, 11) ||
326 !strncmp("cleanup_module", name
, 14) ||
327 strstr(name
, "_text_start") ||
328 strstr(name
, "_text_end"))
331 syme
= dso__sym_priv(self
, sym
);
332 /* Tag events to be skipped. */
333 if (!strcmp("default_idle", name
) ||
334 !strcmp("cpu_idle", name
) ||
335 !strcmp("enter_idle", name
) ||
336 !strcmp("exit_idle", name
) ||
337 !strcmp("mwait_idle", name
))
340 if (filter_match
== 1) {
341 filter_end
= sym
->start
;
343 if (filter_end
- filter_start
> 10000) {
345 "hm, too large filter symbol <%s> - skipping.\n",
347 fprintf(stderr
, "symbol filter start: %016lx\n",
349 fprintf(stderr
, " end: %016lx\n",
351 filter_end
= filter_start
= 0;
357 if (filter_match
== 0 && sym_filter
&& !strcmp(name
, sym_filter
)) {
359 filter_start
= sym
->start
;
366 static int parse_symbols(void)
368 struct rb_node
*node
;
371 kernel_dso
= dso__new("[kernel]", sizeof(struct sym_entry
));
372 if (kernel_dso
== NULL
)
375 if (dso__load_kernel(kernel_dso
, NULL
, symbol_filter
) != 0)
378 node
= rb_first(&kernel_dso
->syms
);
379 sym
= rb_entry(node
, struct symbol
, rb_node
);
382 node
= rb_last(&kernel_dso
->syms
);
383 sym
= rb_entry(node
, struct symbol
, rb_node
);
387 dso__fprintf(kernel_dso
, stderr
);
392 dso__delete(kernel_dso
);
397 #define TRACE_COUNT 3
400 * Binary search in the histogram table and record the hit:
402 static void record_ip(uint64_t ip
, int counter
)
404 struct symbol
*sym
= dso__find_symbol(kernel_dso
, ip
);
407 struct sym_entry
*syme
= dso__sym_priv(kernel_dso
, sym
);
410 syme
->count
[counter
]++;
411 pthread_mutex_lock(&active_symbols_lock
);
412 if (list_empty(&syme
->node
) || !syme
->node
.next
)
413 __list_insert_active_sym(syme
);
414 pthread_mutex_unlock(&active_symbols_lock
);
422 static void process_event(uint64_t ip
, int counter
)
426 if (ip
< min_ip
|| ip
> max_ip
) {
431 record_ip(ip
, counter
);
441 static unsigned int mmap_read_head(struct mmap_data
*md
)
443 struct perf_counter_mmap_page
*pc
= md
->base
;
446 head
= pc
->data_head
;
452 struct timeval last_read
, this_read
;
454 static void mmap_read(struct mmap_data
*md
)
456 unsigned int head
= mmap_read_head(md
);
457 unsigned int old
= md
->prev
;
458 unsigned char *data
= md
->base
+ page_size
;
461 gettimeofday(&this_read
, NULL
);
464 * If we're further behind than half the buffer, there's a chance
465 * the writer will bite our tail and screw up the events under us.
467 * If we somehow ended up ahead of the head, we got messed up.
469 * In either case, truncate and restart at head.
472 if (diff
> md
->mask
/ 2 || diff
< 0) {
476 timersub(&this_read
, &last_read
, &iv
);
477 msecs
= iv
.tv_sec
*1000 + iv
.tv_usec
/1000;
479 fprintf(stderr
, "WARNING: failed to keep up with mmap data."
480 " Last read %lu msecs ago.\n", msecs
);
483 * head points to a known good entry, start there.
488 last_read
= this_read
;
490 for (; old
!= head
;) {
492 struct perf_event_header header
;
494 __u32 pid
, target_pid
;
497 struct perf_event_header header
;
498 __u32 pid
, target_pid
;
502 char filename
[PATH_MAX
];
505 typedef union event_union
{
506 struct perf_event_header header
;
508 struct mmap_event mmap
;
511 event_t
*event
= (event_t
*)&data
[old
& md
->mask
];
515 size_t size
= event
->header
.size
;
518 * Event straddles the mmap boundary -- header should always
519 * be inside due to u64 alignment of output.
521 if ((old
& md
->mask
) + size
!= ((old
+ size
) & md
->mask
)) {
522 unsigned int offset
= old
;
523 unsigned int len
= min(sizeof(*event
), size
), cpy
;
524 void *dst
= &event_copy
;
527 cpy
= min(md
->mask
+ 1 - (offset
& md
->mask
), len
);
528 memcpy(dst
, &data
[offset
& md
->mask
], cpy
);
539 if (event
->header
.misc
& PERF_EVENT_MISC_OVERFLOW
) {
540 if (event
->header
.type
& PERF_RECORD_IP
)
541 process_event(event
->ip
.ip
, md
->counter
);
543 switch (event
->header
.type
) {
544 case PERF_EVENT_MMAP
:
545 case PERF_EVENT_MUNMAP
:
546 printf("%s: %Lu %Lu %Lu %s\n",
547 event
->header
.type
== PERF_EVENT_MMAP
552 event
->mmap
.filename
);
561 static struct pollfd event_array
[MAX_NR_CPUS
* MAX_COUNTERS
];
562 static struct mmap_data mmap_array
[MAX_NR_CPUS
][MAX_COUNTERS
];
564 static int __cmd_top(void)
566 struct perf_counter_hw_event hw_event
;
568 int i
, counter
, group_fd
, nr_poll
= 0;
572 for (i
= 0; i
< nr_cpus
; i
++) {
574 for (counter
= 0; counter
< nr_counters
; counter
++) {
577 if (target_pid
== -1 && profile_cpu
== -1)
580 memset(&hw_event
, 0, sizeof(hw_event
));
581 hw_event
.config
= event_id
[counter
];
582 hw_event
.irq_period
= event_count
[counter
];
583 hw_event
.record_type
= PERF_RECORD_IP
| PERF_RECORD_TID
;
584 hw_event
.mmap
= use_mmap
;
585 hw_event
.munmap
= use_munmap
;
586 hw_event
.freq
= freq
;
588 fd
[i
][counter
] = sys_perf_counter_open(&hw_event
, target_pid
, cpu
, group_fd
, 0);
589 if (fd
[i
][counter
] < 0) {
591 printf("kerneltop error: syscall returned with %d (%s)\n",
592 fd
[i
][counter
], strerror(err
));
594 printf("Are you root?\n");
597 assert(fd
[i
][counter
] >= 0);
598 fcntl(fd
[i
][counter
], F_SETFL
, O_NONBLOCK
);
601 * First counter acts as the group leader:
603 if (group
&& group_fd
== -1)
604 group_fd
= fd
[i
][counter
];
606 event_array
[nr_poll
].fd
= fd
[i
][counter
];
607 event_array
[nr_poll
].events
= POLLIN
;
610 mmap_array
[i
][counter
].counter
= counter
;
611 mmap_array
[i
][counter
].prev
= 0;
612 mmap_array
[i
][counter
].mask
= mmap_pages
*page_size
- 1;
613 mmap_array
[i
][counter
].base
= mmap(NULL
, (mmap_pages
+1)*page_size
,
614 PROT_READ
, MAP_SHARED
, fd
[i
][counter
], 0);
615 if (mmap_array
[i
][counter
].base
== MAP_FAILED
) {
616 printf("kerneltop error: failed to mmap with %d (%s)\n",
617 errno
, strerror(errno
));
623 if (pthread_create(&thread
, NULL
, display_thread
, NULL
)) {
624 printf("Could not create display thread.\n");
629 struct sched_param param
;
631 param
.sched_priority
= realtime_prio
;
632 if (sched_setscheduler(0, SCHED_FIFO
, ¶m
)) {
633 printf("Could not set realtime priority.\n");
641 for (i
= 0; i
< nr_cpus
; i
++) {
642 for (counter
= 0; counter
< nr_counters
; counter
++)
643 mmap_read(&mmap_array
[i
][counter
]);
647 ret
= poll(event_array
, nr_poll
, 100);
653 static const char * const top_usage
[] = {
654 "perf top [<options>]",
658 static char events_help_msg
[EVENTS_HELP_MAX
];
660 static const struct option options
[] = {
661 OPT_CALLBACK('e', "event", NULL
, "event",
662 events_help_msg
, parse_events
),
663 OPT_INTEGER('c', "count", &default_interval
,
664 "event period to sample"),
665 OPT_INTEGER('p', "pid", &target_pid
,
666 "profile events on existing pid"),
667 OPT_BOOLEAN('a', "all-cpus", &system_wide
,
668 "system-wide collection from all CPUs"),
669 OPT_INTEGER('C', "CPU", &profile_cpu
,
670 "CPU to profile on"),
671 OPT_INTEGER('m', "mmap-pages", &mmap_pages
,
672 "number of mmap data pages"),
673 OPT_INTEGER('r', "realtime", &realtime_prio
,
674 "collect data with this RT SCHED_FIFO priority"),
675 OPT_INTEGER('d', "delay", &delay_secs
,
676 "number of seconds to delay between refreshes"),
677 OPT_BOOLEAN('D', "dump-symtab", &dump_symtab
,
678 "dump the symbol table used for profiling"),
679 OPT_INTEGER('f', "--count-filter", &count_filter
,
680 "only display functions with more events than this"),
681 OPT_BOOLEAN('g', "group", &group
,
682 "put the counters into a counter group"),
683 OPT_STRING('s', "sym-filter", &sym_filter
, "pattern",
684 "only display symbols matchig this pattern"),
685 OPT_BOOLEAN('z', "zero", &group
,
686 "zero history across updates"),
687 OPT_BOOLEAN('M', "use-mmap", &use_mmap
,
688 "track mmap events"),
689 OPT_BOOLEAN('U', "use-munmap", &use_munmap
,
690 "track munmap events"),
691 OPT_INTEGER('F', "--freq", &freq
,
692 "profile at this frequency"),
696 int cmd_top(int argc
, const char **argv
, const char *prefix
)
700 page_size
= sysconf(_SC_PAGE_SIZE
);
702 create_events_help(events_help_msg
);
703 memcpy(event_id
, default_event_id
, sizeof(default_event_id
));
705 argc
= parse_options(argc
, argv
, options
, top_usage
, 0);
707 usage_with_options(top_usage
, options
);
710 default_interval
= freq
;
714 /* CPU and PID are mutually exclusive */
715 if (target_pid
!= -1 && profile_cpu
!= -1) {
716 printf("WARNING: PID switch overriding CPU\n");
726 for (counter
= 0; counter
< nr_counters
; counter
++) {
727 if (event_count
[counter
])
730 event_count
[counter
] = default_interval
;
733 nr_cpus
= sysconf(_SC_NPROCESSORS_ONLN
);
734 assert(nr_cpus
<= MAX_NR_CPUS
);
735 assert(nr_cpus
>= 0);
737 if (target_pid
!= -1 || profile_cpu
!= -1)