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