]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - tools/perf/builtin-kmem.c
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[mirror_ubuntu-zesty-kernel.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 #include <linux/slab.h>
18
19 struct alloc_stat;
20 typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);
21
22 static char const *input_name = "perf.data";
23
24 static int alloc_flag;
25 static int caller_flag;
26
27 static int alloc_lines = -1;
28 static int caller_lines = -1;
29
30 static bool raw_ip;
31
32 static char default_sort_order[] = "frag,hit,bytes";
33
34 static int *cpunode_map;
35 static int max_cpu_num;
36
37 struct alloc_stat {
38 u64 call_site;
39 u64 ptr;
40 u64 bytes_req;
41 u64 bytes_alloc;
42 u32 hit;
43 u32 pingpong;
44
45 short alloc_cpu;
46
47 struct rb_node node;
48 };
49
50 static struct rb_root root_alloc_stat;
51 static struct rb_root root_alloc_sorted;
52 static struct rb_root root_caller_stat;
53 static struct rb_root root_caller_sorted;
54
55 static unsigned long total_requested, total_allocated;
56 static unsigned long nr_allocs, nr_cross_allocs;
57
58 #define PATH_SYS_NODE "/sys/devices/system/node"
59
60 static void init_cpunode_map(void)
61 {
62 FILE *fp;
63 int i;
64
65 fp = fopen("/sys/devices/system/cpu/kernel_max", "r");
66 if (!fp) {
67 max_cpu_num = 4096;
68 return;
69 }
70
71 if (fscanf(fp, "%d", &max_cpu_num) < 1)
72 die("Failed to read 'kernel_max' from sysfs");
73 max_cpu_num++;
74
75 cpunode_map = calloc(max_cpu_num, sizeof(int));
76 if (!cpunode_map)
77 die("calloc");
78 for (i = 0; i < max_cpu_num; i++)
79 cpunode_map[i] = -1;
80 fclose(fp);
81 }
82
83 static void setup_cpunode_map(void)
84 {
85 struct dirent *dent1, *dent2;
86 DIR *dir1, *dir2;
87 unsigned int cpu, mem;
88 char buf[PATH_MAX];
89
90 init_cpunode_map();
91
92 dir1 = opendir(PATH_SYS_NODE);
93 if (!dir1)
94 return;
95
96 while ((dent1 = readdir(dir1)) != NULL) {
97 if (dent1->d_type != DT_DIR ||
98 sscanf(dent1->d_name, "node%u", &mem) < 1)
99 continue;
100
101 snprintf(buf, PATH_MAX, "%s/%s", PATH_SYS_NODE, dent1->d_name);
102 dir2 = opendir(buf);
103 if (!dir2)
104 continue;
105 while ((dent2 = readdir(dir2)) != NULL) {
106 if (dent2->d_type != DT_LNK ||
107 sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
108 continue;
109 cpunode_map[cpu] = mem;
110 }
111 }
112 }
113
114 static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
115 int bytes_req, int bytes_alloc, int cpu)
116 {
117 struct rb_node **node = &root_alloc_stat.rb_node;
118 struct rb_node *parent = NULL;
119 struct alloc_stat *data = NULL;
120
121 while (*node) {
122 parent = *node;
123 data = rb_entry(*node, struct alloc_stat, node);
124
125 if (ptr > data->ptr)
126 node = &(*node)->rb_right;
127 else if (ptr < data->ptr)
128 node = &(*node)->rb_left;
129 else
130 break;
131 }
132
133 if (data && data->ptr == ptr) {
134 data->hit++;
135 data->bytes_req += bytes_req;
136 data->bytes_alloc += bytes_alloc;
137 } else {
138 data = malloc(sizeof(*data));
139 if (!data)
140 die("malloc");
141 data->ptr = ptr;
142 data->pingpong = 0;
143 data->hit = 1;
144 data->bytes_req = bytes_req;
145 data->bytes_alloc = bytes_alloc;
146
147 rb_link_node(&data->node, parent, node);
148 rb_insert_color(&data->node, &root_alloc_stat);
149 }
150 data->call_site = call_site;
151 data->alloc_cpu = cpu;
152 }
153
154 static void insert_caller_stat(unsigned long call_site,
155 int bytes_req, int bytes_alloc)
156 {
157 struct rb_node **node = &root_caller_stat.rb_node;
158 struct rb_node *parent = NULL;
159 struct alloc_stat *data = NULL;
160
161 while (*node) {
162 parent = *node;
163 data = rb_entry(*node, struct alloc_stat, node);
164
165 if (call_site > data->call_site)
166 node = &(*node)->rb_right;
167 else if (call_site < data->call_site)
168 node = &(*node)->rb_left;
169 else
170 break;
171 }
172
173 if (data && data->call_site == call_site) {
174 data->hit++;
175 data->bytes_req += bytes_req;
176 data->bytes_alloc += bytes_alloc;
177 } else {
178 data = malloc(sizeof(*data));
179 if (!data)
180 die("malloc");
181 data->call_site = call_site;
182 data->pingpong = 0;
183 data->hit = 1;
184 data->bytes_req = bytes_req;
185 data->bytes_alloc = bytes_alloc;
186
187 rb_link_node(&data->node, parent, node);
188 rb_insert_color(&data->node, &root_caller_stat);
189 }
190 }
191
192 static void process_alloc_event(void *data,
193 struct event *event,
194 int cpu,
195 u64 timestamp __used,
196 struct thread *thread __used,
197 int node)
198 {
199 unsigned long call_site;
200 unsigned long ptr;
201 int bytes_req;
202 int bytes_alloc;
203 int node1, node2;
204
205 ptr = raw_field_value(event, "ptr", data);
206 call_site = raw_field_value(event, "call_site", data);
207 bytes_req = raw_field_value(event, "bytes_req", data);
208 bytes_alloc = raw_field_value(event, "bytes_alloc", data);
209
210 insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
211 insert_caller_stat(call_site, bytes_req, bytes_alloc);
212
213 total_requested += bytes_req;
214 total_allocated += bytes_alloc;
215
216 if (node) {
217 node1 = cpunode_map[cpu];
218 node2 = raw_field_value(event, "node", data);
219 if (node1 != node2)
220 nr_cross_allocs++;
221 }
222 nr_allocs++;
223 }
224
225 static int ptr_cmp(struct alloc_stat *, struct alloc_stat *);
226 static int callsite_cmp(struct alloc_stat *, struct alloc_stat *);
227
228 static struct alloc_stat *search_alloc_stat(unsigned long ptr,
229 unsigned long call_site,
230 struct rb_root *root,
231 sort_fn_t sort_fn)
232 {
233 struct rb_node *node = root->rb_node;
234 struct alloc_stat key = { .ptr = ptr, .call_site = call_site };
235
236 while (node) {
237 struct alloc_stat *data;
238 int cmp;
239
240 data = rb_entry(node, struct alloc_stat, node);
241
242 cmp = sort_fn(&key, data);
243 if (cmp < 0)
244 node = node->rb_left;
245 else if (cmp > 0)
246 node = node->rb_right;
247 else
248 return data;
249 }
250 return NULL;
251 }
252
253 static void process_free_event(void *data,
254 struct event *event,
255 int cpu,
256 u64 timestamp __used,
257 struct thread *thread __used)
258 {
259 unsigned long ptr;
260 struct alloc_stat *s_alloc, *s_caller;
261
262 ptr = raw_field_value(event, "ptr", data);
263
264 s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp);
265 if (!s_alloc)
266 return;
267
268 if (cpu != s_alloc->alloc_cpu) {
269 s_alloc->pingpong++;
270
271 s_caller = search_alloc_stat(0, s_alloc->call_site,
272 &root_caller_stat, callsite_cmp);
273 assert(s_caller);
274 s_caller->pingpong++;
275 }
276 s_alloc->alloc_cpu = -1;
277 }
278
279 static void
280 process_raw_event(event_t *raw_event __used, void *data,
281 int cpu, u64 timestamp, struct thread *thread)
282 {
283 struct event *event;
284 int type;
285
286 type = trace_parse_common_type(data);
287 event = trace_find_event(type);
288
289 if (!strcmp(event->name, "kmalloc") ||
290 !strcmp(event->name, "kmem_cache_alloc")) {
291 process_alloc_event(data, event, cpu, timestamp, thread, 0);
292 return;
293 }
294
295 if (!strcmp(event->name, "kmalloc_node") ||
296 !strcmp(event->name, "kmem_cache_alloc_node")) {
297 process_alloc_event(data, event, cpu, timestamp, thread, 1);
298 return;
299 }
300
301 if (!strcmp(event->name, "kfree") ||
302 !strcmp(event->name, "kmem_cache_free")) {
303 process_free_event(data, event, cpu, timestamp, thread);
304 return;
305 }
306 }
307
308 static int process_sample_event(event_t *event, struct perf_session *session)
309 {
310 struct sample_data data;
311 struct thread *thread;
312
313 memset(&data, 0, sizeof(data));
314 data.time = -1;
315 data.cpu = -1;
316 data.period = 1;
317
318 event__parse_sample(event, session->sample_type, &data);
319
320 dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
321 data.pid, data.tid, data.ip, data.period);
322
323 thread = perf_session__findnew(session, event->ip.pid);
324 if (thread == NULL) {
325 pr_debug("problem processing %d event, skipping it.\n",
326 event->header.type);
327 return -1;
328 }
329
330 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
331
332 process_raw_event(event, data.raw_data, data.cpu,
333 data.time, thread);
334
335 return 0;
336 }
337
338 static struct perf_event_ops event_ops = {
339 .sample = process_sample_event,
340 .comm = event__process_comm,
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
356 printf("%.102s\n", graph_dotted_line);
357 printf(" %-34s |", is_caller ? "Callsite": "Alloc Ptr");
358 printf(" Total_alloc/Per | Total_req/Per | Hit | Ping-pong | Frag\n");
359 printf("%.102s\n", graph_dotted_line);
360
361 next = rb_first(root);
362
363 while (next && n_lines--) {
364 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
365 node);
366 struct symbol *sym = NULL;
367 char buf[BUFSIZ];
368 u64 addr;
369
370 if (is_caller) {
371 addr = data->call_site;
372 if (!raw_ip)
373 sym = map_groups__find_function(&session->kmaps, addr, NULL);
374 } else
375 addr = data->ptr;
376
377 if (sym != NULL)
378 snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
379 addr - sym->start);
380 else
381 snprintf(buf, sizeof(buf), "%#Lx", addr);
382 printf(" %-34s |", buf);
383
384 printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %8lu | %6.3f%%\n",
385 (unsigned long long)data->bytes_alloc,
386 (unsigned long)data->bytes_alloc / data->hit,
387 (unsigned long long)data->bytes_req,
388 (unsigned long)data->bytes_req / data->hit,
389 (unsigned long)data->hit,
390 (unsigned long)data->pingpong,
391 fragmentation(data->bytes_req, data->bytes_alloc));
392
393 next = rb_next(next);
394 }
395
396 if (n_lines == -1)
397 printf(" ... | ... | ... | ... | ... | ... \n");
398
399 printf("%.102s\n", graph_dotted_line);
400 }
401
402 static void print_summary(void)
403 {
404 printf("\nSUMMARY\n=======\n");
405 printf("Total bytes requested: %lu\n", total_requested);
406 printf("Total bytes allocated: %lu\n", total_allocated);
407 printf("Total bytes wasted on internal fragmentation: %lu\n",
408 total_allocated - total_requested);
409 printf("Internal fragmentation: %f%%\n",
410 fragmentation(total_requested, total_allocated));
411 printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
412 }
413
414 static void print_result(struct perf_session *session)
415 {
416 if (caller_flag)
417 __print_result(&root_caller_sorted, session, caller_lines, 1);
418 if (alloc_flag)
419 __print_result(&root_alloc_sorted, session, alloc_lines, 0);
420 print_summary();
421 }
422
423 struct sort_dimension {
424 const char name[20];
425 sort_fn_t cmp;
426 struct list_head list;
427 };
428
429 static LIST_HEAD(caller_sort);
430 static LIST_HEAD(alloc_sort);
431
432 static void sort_insert(struct rb_root *root, struct alloc_stat *data,
433 struct list_head *sort_list)
434 {
435 struct rb_node **new = &(root->rb_node);
436 struct rb_node *parent = NULL;
437 struct sort_dimension *sort;
438
439 while (*new) {
440 struct alloc_stat *this;
441 int cmp = 0;
442
443 this = rb_entry(*new, struct alloc_stat, node);
444 parent = *new;
445
446 list_for_each_entry(sort, sort_list, list) {
447 cmp = sort->cmp(data, this);
448 if (cmp)
449 break;
450 }
451
452 if (cmp > 0)
453 new = &((*new)->rb_left);
454 else
455 new = &((*new)->rb_right);
456 }
457
458 rb_link_node(&data->node, parent, new);
459 rb_insert_color(&data->node, root);
460 }
461
462 static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
463 struct list_head *sort_list)
464 {
465 struct rb_node *node;
466 struct alloc_stat *data;
467
468 for (;;) {
469 node = rb_first(root);
470 if (!node)
471 break;
472
473 rb_erase(node, root);
474 data = rb_entry(node, struct alloc_stat, node);
475 sort_insert(root_sorted, data, sort_list);
476 }
477 }
478
479 static void sort_result(void)
480 {
481 __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
482 __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
483 }
484
485 static int __cmd_kmem(void)
486 {
487 int err = -EINVAL;
488 struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
489 if (session == NULL)
490 return -ENOMEM;
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 "-M",
723 "-f",
724 "-c", "1",
725 "-e", "kmem:kmalloc",
726 "-e", "kmem:kmalloc_node",
727 "-e", "kmem:kfree",
728 "-e", "kmem:kmem_cache_alloc",
729 "-e", "kmem:kmem_cache_alloc_node",
730 "-e", "kmem:kmem_cache_free",
731 };
732
733 static int __cmd_record(int argc, const char **argv)
734 {
735 unsigned int rec_argc, i, j;
736 const char **rec_argv;
737
738 rec_argc = ARRAY_SIZE(record_args) + argc - 1;
739 rec_argv = calloc(rec_argc + 1, sizeof(char *));
740
741 for (i = 0; i < ARRAY_SIZE(record_args); i++)
742 rec_argv[i] = strdup(record_args[i]);
743
744 for (j = 1; j < (unsigned int)argc; j++, i++)
745 rec_argv[i] = argv[j];
746
747 return cmd_record(i, rec_argv, NULL);
748 }
749
750 int cmd_kmem(int argc, const char **argv, const char *prefix __used)
751 {
752 argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
753
754 if (!argc)
755 usage_with_options(kmem_usage, kmem_options);
756
757 symbol__init();
758
759 if (!strncmp(argv[0], "rec", 3)) {
760 return __cmd_record(argc, argv);
761 } else if (!strcmp(argv[0], "stat")) {
762 setup_cpunode_map();
763
764 if (list_empty(&caller_sort))
765 setup_sorting(&caller_sort, default_sort_order);
766 if (list_empty(&alloc_sort))
767 setup_sorting(&alloc_sort, default_sort_order);
768
769 return __cmd_kmem();
770 } else
771 usage_with_options(kmem_usage, kmem_options);
772
773 return 0;
774 }
775