7323d9dfbce87243c534e5621678370187c0e7b3
[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 perf_session *session)
308 {
309         struct sample_data data;
310         struct thread *thread;
311
312         memset(&data, 0, sizeof(data));
313         data.time = -1;
314         data.cpu = -1;
315         data.period = 1;
316
317         event__parse_sample(event, session->sample_type, &data);
318
319         dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
320                     data.pid, data.tid, data.ip, data.period);
321
322         thread = perf_session__findnew(session, event->ip.pid);
323         if (thread == NULL) {
324                 pr_debug("problem processing %d event, skipping it.\n",
325                          event->header.type);
326                 return -1;
327         }
328
329         dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
330
331         process_raw_event(event, data.raw_data, data.cpu,
332                           data.time, thread);
333
334         return 0;
335 }
336
337 static struct perf_event_ops event_ops = {
338         .sample = process_sample_event,
339         .comm   = event__process_comm,
340 };
341
342 static double fragmentation(unsigned long n_req, unsigned long n_alloc)
343 {
344         if (n_alloc == 0)
345                 return 0.0;
346         else
347                 return 100.0 - (100.0 * n_req / n_alloc);
348 }
349
350 static void __print_result(struct rb_root *root, struct perf_session *session,
351                            int n_lines, int is_caller)
352 {
353         struct rb_node *next;
354
355         printf("%.102s\n", graph_dotted_line);
356         printf(" %-34s |",  is_caller ? "Callsite": "Alloc Ptr");
357         printf(" Total_alloc/Per | Total_req/Per   | Hit   | Ping-pong | Frag\n");
358         printf("%.102s\n", graph_dotted_line);
359
360         next = rb_first(root);
361
362         while (next && n_lines--) {
363                 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
364                                                    node);
365                 struct symbol *sym = NULL;
366                 char buf[BUFSIZ];
367                 u64 addr;
368
369                 if (is_caller) {
370                         addr = data->call_site;
371                         if (!raw_ip)
372                                 sym = map_groups__find_function(&session->kmaps, session, addr, NULL);
373                 } else
374                         addr = data->ptr;
375
376                 if (sym != NULL)
377                         snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
378                                  addr - sym->start);
379                 else
380                         snprintf(buf, sizeof(buf), "%#Lx", addr);
381                 printf(" %-34s |", buf);
382
383                 printf(" %9llu/%-5lu | %9llu/%-5lu | %6lu | %8lu | %6.3f%%\n",
384                        (unsigned long long)data->bytes_alloc,
385                        (unsigned long)data->bytes_alloc / data->hit,
386                        (unsigned long long)data->bytes_req,
387                        (unsigned long)data->bytes_req / data->hit,
388                        (unsigned long)data->hit,
389                        (unsigned long)data->pingpong,
390                        fragmentation(data->bytes_req, data->bytes_alloc));
391
392                 next = rb_next(next);
393         }
394
395         if (n_lines == -1)
396                 printf(" ...                                | ...             | ...             | ...    | ...      | ...   \n");
397
398         printf("%.102s\n", graph_dotted_line);
399 }
400
401 static void print_summary(void)
402 {
403         printf("\nSUMMARY\n=======\n");
404         printf("Total bytes requested: %lu\n", total_requested);
405         printf("Total bytes allocated: %lu\n", total_allocated);
406         printf("Total bytes wasted on internal fragmentation: %lu\n",
407                total_allocated - total_requested);
408         printf("Internal fragmentation: %f%%\n",
409                fragmentation(total_requested, total_allocated));
410         printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
411 }
412
413 static void print_result(struct perf_session *session)
414 {
415         if (caller_flag)
416                 __print_result(&root_caller_sorted, session, caller_lines, 1);
417         if (alloc_flag)
418                 __print_result(&root_alloc_sorted, session, alloc_lines, 0);
419         print_summary();
420 }
421
422 struct sort_dimension {
423         const char              name[20];
424         sort_fn_t               cmp;
425         struct list_head        list;
426 };
427
428 static LIST_HEAD(caller_sort);
429 static LIST_HEAD(alloc_sort);
430
431 static void sort_insert(struct rb_root *root, struct alloc_stat *data,
432                         struct list_head *sort_list)
433 {
434         struct rb_node **new = &(root->rb_node);
435         struct rb_node *parent = NULL;
436         struct sort_dimension *sort;
437
438         while (*new) {
439                 struct alloc_stat *this;
440                 int cmp = 0;
441
442                 this = rb_entry(*new, struct alloc_stat, node);
443                 parent = *new;
444
445                 list_for_each_entry(sort, sort_list, list) {
446                         cmp = sort->cmp(data, this);
447                         if (cmp)
448                                 break;
449                 }
450
451                 if (cmp > 0)
452                         new = &((*new)->rb_left);
453                 else
454                         new = &((*new)->rb_right);
455         }
456
457         rb_link_node(&data->node, parent, new);
458         rb_insert_color(&data->node, root);
459 }
460
461 static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
462                           struct list_head *sort_list)
463 {
464         struct rb_node *node;
465         struct alloc_stat *data;
466
467         for (;;) {
468                 node = rb_first(root);
469                 if (!node)
470                         break;
471
472                 rb_erase(node, root);
473                 data = rb_entry(node, struct alloc_stat, node);
474                 sort_insert(root_sorted, data, sort_list);
475         }
476 }
477
478 static void sort_result(void)
479 {
480         __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
481         __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
482 }
483
484 static int __cmd_kmem(void)
485 {
486         int err = -EINVAL;
487         struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
488         if (session == NULL)
489                 return -ENOMEM;
490
491         if (!perf_session__has_traces(session, "kmem record"))
492                 goto out_delete;
493
494         if (perf_session__create_kernel_maps(session) < 0) {
495                 pr_err("Problems creating kernel maps\n");
496                 return -1;
497         }
498
499         setup_pager();
500         err = perf_session__process_events(session, &event_ops);
501         if (err != 0)
502                 goto out_delete;
503         sort_result();
504         print_result(session);
505 out_delete:
506         perf_session__delete(session);
507         return err;
508 }
509
510 static const char * const kmem_usage[] = {
511         "perf kmem [<options>] {record|stat}",
512         NULL
513 };
514
515 static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r)
516 {
517         if (l->ptr < r->ptr)
518                 return -1;
519         else if (l->ptr > r->ptr)
520                 return 1;
521         return 0;
522 }
523
524 static struct sort_dimension ptr_sort_dimension = {
525         .name   = "ptr",
526         .cmp    = ptr_cmp,
527 };
528
529 static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r)
530 {
531         if (l->call_site < r->call_site)
532                 return -1;
533         else if (l->call_site > r->call_site)
534                 return 1;
535         return 0;
536 }
537
538 static struct sort_dimension callsite_sort_dimension = {
539         .name   = "callsite",
540         .cmp    = callsite_cmp,
541 };
542
543 static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r)
544 {
545         if (l->hit < r->hit)
546                 return -1;
547         else if (l->hit > r->hit)
548                 return 1;
549         return 0;
550 }
551
552 static struct sort_dimension hit_sort_dimension = {
553         .name   = "hit",
554         .cmp    = hit_cmp,
555 };
556
557 static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r)
558 {
559         if (l->bytes_alloc < r->bytes_alloc)
560                 return -1;
561         else if (l->bytes_alloc > r->bytes_alloc)
562                 return 1;
563         return 0;
564 }
565
566 static struct sort_dimension bytes_sort_dimension = {
567         .name   = "bytes",
568         .cmp    = bytes_cmp,
569 };
570
571 static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r)
572 {
573         double x, y;
574
575         x = fragmentation(l->bytes_req, l->bytes_alloc);
576         y = fragmentation(r->bytes_req, r->bytes_alloc);
577
578         if (x < y)
579                 return -1;
580         else if (x > y)
581                 return 1;
582         return 0;
583 }
584
585 static struct sort_dimension frag_sort_dimension = {
586         .name   = "frag",
587         .cmp    = frag_cmp,
588 };
589
590 static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r)
591 {
592         if (l->pingpong < r->pingpong)
593                 return -1;
594         else if (l->pingpong > r->pingpong)
595                 return 1;
596         return 0;
597 }
598
599 static struct sort_dimension pingpong_sort_dimension = {
600         .name   = "pingpong",
601         .cmp    = pingpong_cmp,
602 };
603
604 static struct sort_dimension *avail_sorts[] = {
605         &ptr_sort_dimension,
606         &callsite_sort_dimension,
607         &hit_sort_dimension,
608         &bytes_sort_dimension,
609         &frag_sort_dimension,
610         &pingpong_sort_dimension,
611 };
612
613 #define NUM_AVAIL_SORTS \
614         (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
615
616 static int sort_dimension__add(const char *tok, struct list_head *list)
617 {
618         struct sort_dimension *sort;
619         int i;
620
621         for (i = 0; i < NUM_AVAIL_SORTS; i++) {
622                 if (!strcmp(avail_sorts[i]->name, tok)) {
623                         sort = malloc(sizeof(*sort));
624                         if (!sort)
625                                 die("malloc");
626                         memcpy(sort, avail_sorts[i], sizeof(*sort));
627                         list_add_tail(&sort->list, list);
628                         return 0;
629                 }
630         }
631
632         return -1;
633 }
634
635 static int setup_sorting(struct list_head *sort_list, const char *arg)
636 {
637         char *tok;
638         char *str = strdup(arg);
639
640         if (!str)
641                 die("strdup");
642
643         while (true) {
644                 tok = strsep(&str, ",");
645                 if (!tok)
646                         break;
647                 if (sort_dimension__add(tok, sort_list) < 0) {
648                         error("Unknown --sort key: '%s'", tok);
649                         return -1;
650                 }
651         }
652
653         free(str);
654         return 0;
655 }
656
657 static int parse_sort_opt(const struct option *opt __used,
658                           const char *arg, int unset __used)
659 {
660         if (!arg)
661                 return -1;
662
663         if (caller_flag > alloc_flag)
664                 return setup_sorting(&caller_sort, arg);
665         else
666                 return setup_sorting(&alloc_sort, arg);
667
668         return 0;
669 }
670
671 static int parse_caller_opt(const struct option *opt __used,
672                           const char *arg __used, int unset __used)
673 {
674         caller_flag = (alloc_flag + 1);
675         return 0;
676 }
677
678 static int parse_alloc_opt(const struct option *opt __used,
679                           const char *arg __used, int unset __used)
680 {
681         alloc_flag = (caller_flag + 1);
682         return 0;
683 }
684
685 static int parse_line_opt(const struct option *opt __used,
686                           const char *arg, int unset __used)
687 {
688         int lines;
689
690         if (!arg)
691                 return -1;
692
693         lines = strtoul(arg, NULL, 10);
694
695         if (caller_flag > alloc_flag)
696                 caller_lines = lines;
697         else
698                 alloc_lines = lines;
699
700         return 0;
701 }
702
703 static const struct option kmem_options[] = {
704         OPT_STRING('i', "input", &input_name, "file",
705                    "input file name"),
706         OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
707                            "show per-callsite statistics",
708                            parse_caller_opt),
709         OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
710                            "show per-allocation statistics",
711                            parse_alloc_opt),
712         OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
713                      "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
714                      parse_sort_opt),
715         OPT_CALLBACK('l', "line", NULL, "num",
716                      "show n lines",
717                      parse_line_opt),
718         OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
719         OPT_END()
720 };
721
722 static const char *record_args[] = {
723         "record",
724         "-a",
725         "-R",
726         "-M",
727         "-f",
728         "-c", "1",
729         "-e", "kmem:kmalloc",
730         "-e", "kmem:kmalloc_node",
731         "-e", "kmem:kfree",
732         "-e", "kmem:kmem_cache_alloc",
733         "-e", "kmem:kmem_cache_alloc_node",
734         "-e", "kmem:kmem_cache_free",
735 };
736
737 static int __cmd_record(int argc, const char **argv)
738 {
739         unsigned int rec_argc, i, j;
740         const char **rec_argv;
741
742         rec_argc = ARRAY_SIZE(record_args) + argc - 1;
743         rec_argv = calloc(rec_argc + 1, sizeof(char *));
744
745         for (i = 0; i < ARRAY_SIZE(record_args); i++)
746                 rec_argv[i] = strdup(record_args[i]);
747
748         for (j = 1; j < (unsigned int)argc; j++, i++)
749                 rec_argv[i] = argv[j];
750
751         return cmd_record(i, rec_argv, NULL);
752 }
753
754 int cmd_kmem(int argc, const char **argv, const char *prefix __used)
755 {
756         argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
757
758         if (!argc)
759                 usage_with_options(kmem_usage, kmem_options);
760
761         symbol__init();
762
763         if (!strncmp(argv[0], "rec", 3)) {
764                 return __cmd_record(argc, argv);
765         } else if (!strcmp(argv[0], "stat")) {
766                 setup_cpunode_map();
767
768                 if (list_empty(&caller_sort))
769                         setup_sorting(&caller_sort, default_sort_order);
770                 if (list_empty(&alloc_sort))
771                         setup_sorting(&alloc_sort, default_sort_order);
772
773                 return __cmd_kmem();
774         }
775
776         return 0;
777 }
778