e79ecbc17181c12d920ed2d3ed6eea66b1f350da
[linux-2.6.git] / tools / perf / builtin-kmem.c
1 #include "builtin.h"
2 #include "perf.h"
3
4 #include "util/util.h"
5 #include "util/cache.h"
6 #include "util/symbol.h"
7 #include "util/thread.h"
8 #include "util/header.h"
9 #include "util/session.h"
10
11 #include "util/parse-options.h"
12 #include "util/trace-event.h"
13
14 #include "util/debug.h"
15
16 #include <linux/rbtree.h>
17
18 struct alloc_stat;
19 typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);
20
21 static char const               *input_name = "perf.data";
22
23 static u64                      sample_type;
24
25 static int                      alloc_flag;
26 static int                      caller_flag;
27
28 static int                      alloc_lines = -1;
29 static int                      caller_lines = -1;
30
31 static bool                     raw_ip;
32
33 static char                     default_sort_order[] = "frag,hit,bytes";
34
35 static int                      *cpunode_map;
36 static int                      max_cpu_num;
37
38 struct alloc_stat {
39         u64     call_site;
40         u64     ptr;
41         u64     bytes_req;
42         u64     bytes_alloc;
43         u32     hit;
44         u32     pingpong;
45
46         short   alloc_cpu;
47
48         struct rb_node node;
49 };
50
51 static struct rb_root root_alloc_stat;
52 static struct rb_root root_alloc_sorted;
53 static struct rb_root root_caller_stat;
54 static struct rb_root root_caller_sorted;
55
56 static unsigned long total_requested, total_allocated;
57 static unsigned long nr_allocs, nr_cross_allocs;
58
59 #define PATH_SYS_NODE   "/sys/devices/system/node"
60
61 static void init_cpunode_map(void)
62 {
63         FILE *fp;
64         int i;
65
66         fp = fopen("/sys/devices/system/cpu/kernel_max", "r");
67         if (!fp) {
68                 max_cpu_num = 4096;
69                 return;
70         }
71
72         if (fscanf(fp, "%d", &max_cpu_num) < 1)
73                 die("Failed to read 'kernel_max' from sysfs");
74         max_cpu_num++;
75
76         cpunode_map = calloc(max_cpu_num, sizeof(int));
77         if (!cpunode_map)
78                 die("calloc");
79         for (i = 0; i < max_cpu_num; i++)
80                 cpunode_map[i] = -1;
81         fclose(fp);
82 }
83
84 static void setup_cpunode_map(void)
85 {
86         struct dirent *dent1, *dent2;
87         DIR *dir1, *dir2;
88         unsigned int cpu, mem;
89         char buf[PATH_MAX];
90
91         init_cpunode_map();
92
93         dir1 = opendir(PATH_SYS_NODE);
94         if (!dir1)
95                 return;
96
97         while (true) {
98                 dent1 = readdir(dir1);
99                 if (!dent1)
100                         break;
101
102                 if (sscanf(dent1->d_name, "node%u", &mem) < 1)
103                         continue;
104
105                 snprintf(buf, PATH_MAX, "%s/%s", PATH_SYS_NODE, dent1->d_name);
106                 dir2 = opendir(buf);
107                 if (!dir2)
108                         continue;
109                 while (true) {
110                         dent2 = readdir(dir2);
111                         if (!dent2)
112                                 break;
113                         if (sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
114                                 continue;
115                         cpunode_map[cpu] = mem;
116                 }
117         }
118 }
119
120 static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
121                               int bytes_req, int bytes_alloc, int cpu)
122 {
123         struct rb_node **node = &root_alloc_stat.rb_node;
124         struct rb_node *parent = NULL;
125         struct alloc_stat *data = NULL;
126
127         while (*node) {
128                 parent = *node;
129                 data = rb_entry(*node, struct alloc_stat, node);
130
131                 if (ptr > data->ptr)
132                         node = &(*node)->rb_right;
133                 else if (ptr < data->ptr)
134                         node = &(*node)->rb_left;
135                 else
136                         break;
137         }
138
139         if (data && data->ptr == ptr) {
140                 data->hit++;
141                 data->bytes_req += bytes_req;
142                 data->bytes_alloc += bytes_req;
143         } else {
144                 data = malloc(sizeof(*data));
145                 if (!data)
146                         die("malloc");
147                 data->ptr = ptr;
148                 data->pingpong = 0;
149                 data->hit = 1;
150                 data->bytes_req = bytes_req;
151                 data->bytes_alloc = bytes_alloc;
152
153                 rb_link_node(&data->node, parent, node);
154                 rb_insert_color(&data->node, &root_alloc_stat);
155         }
156         data->call_site = call_site;
157         data->alloc_cpu = cpu;
158 }
159
160 static void insert_caller_stat(unsigned long call_site,
161                               int bytes_req, int bytes_alloc)
162 {
163         struct rb_node **node = &root_caller_stat.rb_node;
164         struct rb_node *parent = NULL;
165         struct alloc_stat *data = NULL;
166
167         while (*node) {
168                 parent = *node;
169                 data = rb_entry(*node, struct alloc_stat, node);
170
171                 if (call_site > data->call_site)
172                         node = &(*node)->rb_right;
173                 else if (call_site < data->call_site)
174                         node = &(*node)->rb_left;
175                 else
176                         break;
177         }
178
179         if (data && data->call_site == call_site) {
180                 data->hit++;
181                 data->bytes_req += bytes_req;
182                 data->bytes_alloc += bytes_req;
183         } else {
184                 data = malloc(sizeof(*data));
185                 if (!data)
186                         die("malloc");
187                 data->call_site = call_site;
188                 data->pingpong = 0;
189                 data->hit = 1;
190                 data->bytes_req = bytes_req;
191                 data->bytes_alloc = bytes_alloc;
192
193                 rb_link_node(&data->node, parent, node);
194                 rb_insert_color(&data->node, &root_caller_stat);
195         }
196 }
197
198 static void process_alloc_event(void *data,
199                                 struct event *event,
200                                 int cpu,
201                                 u64 timestamp __used,
202                                 struct thread *thread __used,
203                                 int node)
204 {
205         unsigned long call_site;
206         unsigned long ptr;
207         int bytes_req;
208         int bytes_alloc;
209         int node1, node2;
210
211         ptr = raw_field_value(event, "ptr", data);
212         call_site = raw_field_value(event, "call_site", data);
213         bytes_req = raw_field_value(event, "bytes_req", data);
214         bytes_alloc = raw_field_value(event, "bytes_alloc", data);
215
216         insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
217         insert_caller_stat(call_site, bytes_req, bytes_alloc);
218
219         total_requested += bytes_req;
220         total_allocated += bytes_alloc;
221
222         if (node) {
223                 node1 = cpunode_map[cpu];
224                 node2 = raw_field_value(event, "node", data);
225                 if (node1 != node2)
226                         nr_cross_allocs++;
227         }
228         nr_allocs++;
229 }
230
231 static int ptr_cmp(struct alloc_stat *, struct alloc_stat *);
232 static int callsite_cmp(struct alloc_stat *, struct alloc_stat *);
233
234 static struct alloc_stat *search_alloc_stat(unsigned long ptr,
235                                             unsigned long call_site,
236                                             struct rb_root *root,
237                                             sort_fn_t sort_fn)
238 {
239         struct rb_node *node = root->rb_node;
240         struct alloc_stat key = { .ptr = ptr, .call_site = call_site };
241
242         while (node) {
243                 struct alloc_stat *data;
244                 int cmp;
245
246                 data = rb_entry(node, struct alloc_stat, node);
247
248                 cmp = sort_fn(&key, data);
249                 if (cmp < 0)
250                         node = node->rb_left;
251                 else if (cmp > 0)
252                         node = node->rb_right;
253                 else
254                         return data;
255         }
256         return NULL;
257 }
258
259 static void process_free_event(void *data,
260                                struct event *event,
261                                int cpu,
262                                u64 timestamp __used,
263                                struct thread *thread __used)
264 {
265         unsigned long ptr;
266         struct alloc_stat *s_alloc, *s_caller;
267
268         ptr = raw_field_value(event, "ptr", data);
269
270         s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp);
271         if (!s_alloc)
272                 return;
273
274         if (cpu != s_alloc->alloc_cpu) {
275                 s_alloc->pingpong++;
276
277                 s_caller = search_alloc_stat(0, s_alloc->call_site,
278                                              &root_caller_stat, callsite_cmp);
279                 assert(s_caller);
280                 s_caller->pingpong++;
281         }
282         s_alloc->alloc_cpu = -1;
283 }
284
285 static void
286 process_raw_event(event_t *raw_event __used, void *data,
287                   int cpu, u64 timestamp, struct thread *thread)
288 {
289         struct event *event;
290         int type;
291
292         type = trace_parse_common_type(data);
293         event = trace_find_event(type);
294
295         if (!strcmp(event->name, "kmalloc") ||
296             !strcmp(event->name, "kmem_cache_alloc")) {
297                 process_alloc_event(data, event, cpu, timestamp, thread, 0);
298                 return;
299         }
300
301         if (!strcmp(event->name, "kmalloc_node") ||
302             !strcmp(event->name, "kmem_cache_alloc_node")) {
303                 process_alloc_event(data, event, cpu, timestamp, thread, 1);
304                 return;
305         }
306
307         if (!strcmp(event->name, "kfree") ||
308             !strcmp(event->name, "kmem_cache_free")) {
309                 process_free_event(data, event, cpu, timestamp, thread);
310                 return;
311         }
312 }
313
314 static int process_sample_event(event_t *event, struct perf_session *session)
315 {
316         struct sample_data data;
317         struct thread *thread;
318
319         memset(&data, 0, sizeof(data));
320         data.time = -1;
321         data.cpu = -1;
322         data.period = 1;
323
324         event__parse_sample(event, sample_type, &data);
325
326         dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
327                 event->header.misc,
328                 data.pid, data.tid,
329                 (void *)(long)data.ip,
330                 (long long)data.period);
331
332         thread = perf_session__findnew(session, event->ip.pid);
333         if (thread == NULL) {
334                 pr_debug("problem processing %d event, skipping it.\n",
335                          event->header.type);
336                 return -1;
337         }
338
339         dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
340
341         process_raw_event(event, data.raw_data, data.cpu,
342                           data.time, thread);
343
344         return 0;
345 }
346
347 static int sample_type_check(u64 type)
348 {
349         sample_type = type;
350
351         if (!(sample_type & PERF_SAMPLE_RAW)) {
352                 fprintf(stderr,
353                         "No trace sample to read. Did you call perf record "
354                         "without -R?");
355                 return -1;
356         }
357
358         return 0;
359 }
360
361 static struct perf_event_ops event_ops = {
362         .process_sample_event   = process_sample_event,
363         .process_comm_event     = event__process_comm,
364         .sample_type_check      = sample_type_check,
365 };
366
367 static double fragmentation(unsigned long n_req, unsigned long n_alloc)
368 {
369         if (n_alloc == 0)
370                 return 0.0;
371         else
372                 return 100.0 - (100.0 * n_req / n_alloc);
373 }
374
375 static void __print_result(struct rb_root *root, struct perf_session *session,
376                            int n_lines, int is_caller)
377 {
378         struct rb_node *next;
379
380         printf("%.102s\n", graph_dotted_line);
381         printf(" %-34s |",  is_caller ? "Callsite": "Alloc Ptr");
382         printf(" Total_alloc/Per | Total_req/Per   | Hit   | Ping-pong | Frag\n");
383         printf("%.102s\n", graph_dotted_line);
384
385         next = rb_first(root);
386
387         while (next && n_lines--) {
388                 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
389                                                    node);
390                 struct symbol *sym = NULL;
391                 char buf[BUFSIZ];
392                 u64 addr;
393
394                 if (is_caller) {
395                         addr = data->call_site;
396                         if (!raw_ip)
397                                 sym = map_groups__find_function(&session->kmaps, session, addr, NULL);
398                 } else
399                         addr = data->ptr;
400
401                 if (sym != NULL)
402                         snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
403                                  addr - sym->start);
404                 else
405                         snprintf(buf, sizeof(buf), "%#Lx", addr);
406                 printf(" %-34s |", buf);
407
408                 printf(" %9llu/%-5lu | %9llu/%-5lu | %6lu | %8lu | %6.3f%%\n",
409                        (unsigned long long)data->bytes_alloc,
410                        (unsigned long)data->bytes_alloc / data->hit,
411                        (unsigned long long)data->bytes_req,
412                        (unsigned long)data->bytes_req / data->hit,
413                        (unsigned long)data->hit,
414                        (unsigned long)data->pingpong,
415                        fragmentation(data->bytes_req, data->bytes_alloc));
416
417                 next = rb_next(next);
418         }
419
420         if (n_lines == -1)
421                 printf(" ...                                | ...             | ...             | ...    | ...      | ...   \n");
422
423         printf("%.102s\n", graph_dotted_line);
424 }
425
426 static void print_summary(void)
427 {
428         printf("\nSUMMARY\n=======\n");
429         printf("Total bytes requested: %lu\n", total_requested);
430         printf("Total bytes allocated: %lu\n", total_allocated);
431         printf("Total bytes wasted on internal fragmentation: %lu\n",
432                total_allocated - total_requested);
433         printf("Internal fragmentation: %f%%\n",
434                fragmentation(total_requested, total_allocated));
435         printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
436 }
437
438 static void print_result(struct perf_session *session)
439 {
440         if (caller_flag)
441                 __print_result(&root_caller_sorted, session, caller_lines, 1);
442         if (alloc_flag)
443                 __print_result(&root_alloc_sorted, session, alloc_lines, 0);
444         print_summary();
445 }
446
447 struct sort_dimension {
448         const char              name[20];
449         sort_fn_t               cmp;
450         struct list_head        list;
451 };
452
453 static LIST_HEAD(caller_sort);
454 static LIST_HEAD(alloc_sort);
455
456 static void sort_insert(struct rb_root *root, struct alloc_stat *data,
457                         struct list_head *sort_list)
458 {
459         struct rb_node **new = &(root->rb_node);
460         struct rb_node *parent = NULL;
461         struct sort_dimension *sort;
462
463         while (*new) {
464                 struct alloc_stat *this;
465                 int cmp = 0;
466
467                 this = rb_entry(*new, struct alloc_stat, node);
468                 parent = *new;
469
470                 list_for_each_entry(sort, sort_list, list) {
471                         cmp = sort->cmp(data, this);
472                         if (cmp)
473                                 break;
474                 }
475
476                 if (cmp > 0)
477                         new = &((*new)->rb_left);
478                 else
479                         new = &((*new)->rb_right);
480         }
481
482         rb_link_node(&data->node, parent, new);
483         rb_insert_color(&data->node, root);
484 }
485
486 static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
487                           struct list_head *sort_list)
488 {
489         struct rb_node *node;
490         struct alloc_stat *data;
491
492         for (;;) {
493                 node = rb_first(root);
494                 if (!node)
495                         break;
496
497                 rb_erase(node, root);
498                 data = rb_entry(node, struct alloc_stat, node);
499                 sort_insert(root_sorted, data, sort_list);
500         }
501 }
502
503 static void sort_result(void)
504 {
505         __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
506         __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
507 }
508
509 static int __cmd_kmem(void)
510 {
511         int err;
512         struct perf_session *session = perf_session__new(input_name, O_RDONLY,
513                                                          0, NULL);
514         if (session == NULL)
515                 return -ENOMEM;
516
517         setup_pager();
518         err = perf_session__process_events(session, &event_ops);
519         if (err != 0)
520                 goto out_delete;
521         sort_result();
522         print_result(session);
523 out_delete:
524         perf_session__delete(session);
525         return err;
526 }
527
528 static const char * const kmem_usage[] = {
529         "perf kmem [<options>] {record|stat}",
530         NULL
531 };
532
533 static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r)
534 {
535         if (l->ptr < r->ptr)
536                 return -1;
537         else if (l->ptr > r->ptr)
538                 return 1;
539         return 0;
540 }
541
542 static struct sort_dimension ptr_sort_dimension = {
543         .name   = "ptr",
544         .cmp    = ptr_cmp,
545 };
546
547 static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r)
548 {
549         if (l->call_site < r->call_site)
550                 return -1;
551         else if (l->call_site > r->call_site)
552                 return 1;
553         return 0;
554 }
555
556 static struct sort_dimension callsite_sort_dimension = {
557         .name   = "callsite",
558         .cmp    = callsite_cmp,
559 };
560
561 static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r)
562 {
563         if (l->hit < r->hit)
564                 return -1;
565         else if (l->hit > r->hit)
566                 return 1;
567         return 0;
568 }
569
570 static struct sort_dimension hit_sort_dimension = {
571         .name   = "hit",
572         .cmp    = hit_cmp,
573 };
574
575 static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r)
576 {
577         if (l->bytes_alloc < r->bytes_alloc)
578                 return -1;
579         else if (l->bytes_alloc > r->bytes_alloc)
580                 return 1;
581         return 0;
582 }
583
584 static struct sort_dimension bytes_sort_dimension = {
585         .name   = "bytes",
586         .cmp    = bytes_cmp,
587 };
588
589 static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r)
590 {
591         double x, y;
592
593         x = fragmentation(l->bytes_req, l->bytes_alloc);
594         y = fragmentation(r->bytes_req, r->bytes_alloc);
595
596         if (x < y)
597                 return -1;
598         else if (x > y)
599                 return 1;
600         return 0;
601 }
602
603 static struct sort_dimension frag_sort_dimension = {
604         .name   = "frag",
605         .cmp    = frag_cmp,
606 };
607
608 static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r)
609 {
610         if (l->pingpong < r->pingpong)
611                 return -1;
612         else if (l->pingpong > r->pingpong)
613                 return 1;
614         return 0;
615 }
616
617 static struct sort_dimension pingpong_sort_dimension = {
618         .name   = "pingpong",
619         .cmp    = pingpong_cmp,
620 };
621
622 static struct sort_dimension *avail_sorts[] = {
623         &ptr_sort_dimension,
624         &callsite_sort_dimension,
625         &hit_sort_dimension,
626         &bytes_sort_dimension,
627         &frag_sort_dimension,
628         &pingpong_sort_dimension,
629 };
630
631 #define NUM_AVAIL_SORTS \
632         (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
633
634 static int sort_dimension__add(const char *tok, struct list_head *list)
635 {
636         struct sort_dimension *sort;
637         int i;
638
639         for (i = 0; i < NUM_AVAIL_SORTS; i++) {
640                 if (!strcmp(avail_sorts[i]->name, tok)) {
641                         sort = malloc(sizeof(*sort));
642                         if (!sort)
643                                 die("malloc");
644                         memcpy(sort, avail_sorts[i], sizeof(*sort));
645                         list_add_tail(&sort->list, list);
646                         return 0;
647                 }
648         }
649
650         return -1;
651 }
652
653 static int setup_sorting(struct list_head *sort_list, const char *arg)
654 {
655         char *tok;
656         char *str = strdup(arg);
657
658         if (!str)
659                 die("strdup");
660
661         while (true) {
662                 tok = strsep(&str, ",");
663                 if (!tok)
664                         break;
665                 if (sort_dimension__add(tok, sort_list) < 0) {
666                         error("Unknown --sort key: '%s'", tok);
667                         return -1;
668                 }
669         }
670
671         free(str);
672         return 0;
673 }
674
675 static int parse_sort_opt(const struct option *opt __used,
676                           const char *arg, int unset __used)
677 {
678         if (!arg)
679                 return -1;
680
681         if (caller_flag > alloc_flag)
682                 return setup_sorting(&caller_sort, arg);
683         else
684                 return setup_sorting(&alloc_sort, arg);
685
686         return 0;
687 }
688
689 static int parse_caller_opt(const struct option *opt __used,
690                           const char *arg __used, int unset __used)
691 {
692         caller_flag = (alloc_flag + 1);
693         return 0;
694 }
695
696 static int parse_alloc_opt(const struct option *opt __used,
697                           const char *arg __used, int unset __used)
698 {
699         alloc_flag = (caller_flag + 1);
700         return 0;
701 }
702
703 static int parse_line_opt(const struct option *opt __used,
704                           const char *arg, int unset __used)
705 {
706         int lines;
707
708         if (!arg)
709                 return -1;
710
711         lines = strtoul(arg, NULL, 10);
712
713         if (caller_flag > alloc_flag)
714                 caller_lines = lines;
715         else
716                 alloc_lines = lines;
717
718         return 0;
719 }
720
721 static const struct option kmem_options[] = {
722         OPT_STRING('i', "input", &input_name, "file",
723                    "input file name"),
724         OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
725                            "show per-callsite statistics",
726                            parse_caller_opt),
727         OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
728                            "show per-allocation statistics",
729                            parse_alloc_opt),
730         OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
731                      "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
732                      parse_sort_opt),
733         OPT_CALLBACK('l', "line", NULL, "num",
734                      "show n lines",
735                      parse_line_opt),
736         OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
737         OPT_END()
738 };
739
740 static const char *record_args[] = {
741         "record",
742         "-a",
743         "-R",
744         "-M",
745         "-f",
746         "-c", "1",
747         "-e", "kmem:kmalloc",
748         "-e", "kmem:kmalloc_node",
749         "-e", "kmem:kfree",
750         "-e", "kmem:kmem_cache_alloc",
751         "-e", "kmem:kmem_cache_alloc_node",
752         "-e", "kmem:kmem_cache_free",
753 };
754
755 static int __cmd_record(int argc, const char **argv)
756 {
757         unsigned int rec_argc, i, j;
758         const char **rec_argv;
759
760         rec_argc = ARRAY_SIZE(record_args) + argc - 1;
761         rec_argv = calloc(rec_argc + 1, sizeof(char *));
762
763         for (i = 0; i < ARRAY_SIZE(record_args); i++)
764                 rec_argv[i] = strdup(record_args[i]);
765
766         for (j = 1; j < (unsigned int)argc; j++, i++)
767                 rec_argv[i] = argv[j];
768
769         return cmd_record(i, rec_argv, NULL);
770 }
771
772 int cmd_kmem(int argc, const char **argv, const char *prefix __used)
773 {
774         symbol__init(0);
775
776         argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
777
778         if (!argc)
779                 usage_with_options(kmem_usage, kmem_options);
780
781         if (!strncmp(argv[0], "rec", 3)) {
782                 return __cmd_record(argc, argv);
783         } else if (!strcmp(argv[0], "stat")) {
784                 setup_cpunode_map();
785
786                 if (list_empty(&caller_sort))
787                         setup_sorting(&caller_sort, default_sort_order);
788                 if (list_empty(&alloc_sort))
789                         setup_sorting(&alloc_sort, default_sort_order);
790
791                 return __cmd_kmem();
792         }
793
794         return 0;
795 }
796