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