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 #include "util/tool.h"
12 #include "util/parse-options.h"
13 #include "util/trace-event.h"
15 #include "util/debug.h"
17 #include <linux/rbtree.h>
20 typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);
22 static char const *input_name = "perf.data";
24 static int alloc_flag;
25 static int caller_flag;
27 static int alloc_lines = -1;
28 static int caller_lines = -1;
32 static char default_sort_order[] = "frag,hit,bytes";
34 static int *cpunode_map;
35 static int max_cpu_num;
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;
55 static unsigned long total_requested, total_allocated;
56 static unsigned long nr_allocs, nr_cross_allocs;
58 #define PATH_SYS_NODE "/sys/devices/system/node"
60 static void init_cpunode_map(void)
65 fp = fopen("/sys/devices/system/cpu/kernel_max", "r");
71 if (fscanf(fp, "%d", &max_cpu_num) < 1)
72 die("Failed to read 'kernel_max' from sysfs");
75 cpunode_map = calloc(max_cpu_num, sizeof(int));
78 for (i = 0; i < max_cpu_num; i++)
83 static void setup_cpunode_map(void)
85 struct dirent *dent1, *dent2;
87 unsigned int cpu, mem;
92 dir1 = opendir(PATH_SYS_NODE);
96 while ((dent1 = readdir(dir1)) != NULL) {
97 if (dent1->d_type != DT_DIR ||
98 sscanf(dent1->d_name, "node%u", &mem) < 1)
101 snprintf(buf, PATH_MAX, "%s/%s", PATH_SYS_NODE, dent1->d_name);
105 while ((dent2 = readdir(dir2)) != NULL) {
106 if (dent2->d_type != DT_LNK ||
107 sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
109 cpunode_map[cpu] = mem;
114 static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
115 int bytes_req, int bytes_alloc, int cpu)
117 struct rb_node **node = &root_alloc_stat.rb_node;
118 struct rb_node *parent = NULL;
119 struct alloc_stat *data = NULL;
123 data = rb_entry(*node, struct alloc_stat, node);
126 node = &(*node)->rb_right;
127 else if (ptr < data->ptr)
128 node = &(*node)->rb_left;
133 if (data && data->ptr == ptr) {
135 data->bytes_req += bytes_req;
136 data->bytes_alloc += bytes_alloc;
138 data = malloc(sizeof(*data));
144 data->bytes_req = bytes_req;
145 data->bytes_alloc = bytes_alloc;
147 rb_link_node(&data->node, parent, node);
148 rb_insert_color(&data->node, &root_alloc_stat);
150 data->call_site = call_site;
151 data->alloc_cpu = cpu;
154 static void insert_caller_stat(unsigned long call_site,
155 int bytes_req, int bytes_alloc)
157 struct rb_node **node = &root_caller_stat.rb_node;
158 struct rb_node *parent = NULL;
159 struct alloc_stat *data = NULL;
163 data = rb_entry(*node, struct alloc_stat, node);
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;
173 if (data && data->call_site == call_site) {
175 data->bytes_req += bytes_req;
176 data->bytes_alloc += bytes_alloc;
178 data = malloc(sizeof(*data));
181 data->call_site = call_site;
184 data->bytes_req = bytes_req;
185 data->bytes_alloc = bytes_alloc;
187 rb_link_node(&data->node, parent, node);
188 rb_insert_color(&data->node, &root_caller_stat);
192 static void process_alloc_event(void *data,
195 u64 timestamp __used,
196 struct thread *thread __used,
199 unsigned long call_site;
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);
210 insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
211 insert_caller_stat(call_site, bytes_req, bytes_alloc);
213 total_requested += bytes_req;
214 total_allocated += bytes_alloc;
217 node1 = cpunode_map[cpu];
218 node2 = raw_field_value(event, "node", data);
225 static int ptr_cmp(struct alloc_stat *, struct alloc_stat *);
226 static int callsite_cmp(struct alloc_stat *, struct alloc_stat *);
228 static struct alloc_stat *search_alloc_stat(unsigned long ptr,
229 unsigned long call_site,
230 struct rb_root *root,
233 struct rb_node *node = root->rb_node;
234 struct alloc_stat key = { .ptr = ptr, .call_site = call_site };
237 struct alloc_stat *data;
240 data = rb_entry(node, struct alloc_stat, node);
242 cmp = sort_fn(&key, data);
244 node = node->rb_left;
246 node = node->rb_right;
253 static void process_free_event(void *data,
256 u64 timestamp __used,
257 struct thread *thread __used)
260 struct alloc_stat *s_alloc, *s_caller;
262 ptr = raw_field_value(event, "ptr", data);
264 s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp);
268 if (cpu != s_alloc->alloc_cpu) {
271 s_caller = search_alloc_stat(0, s_alloc->call_site,
272 &root_caller_stat, callsite_cmp);
274 s_caller->pingpong++;
276 s_alloc->alloc_cpu = -1;
279 static void process_raw_event(union perf_event *raw_event __used, void *data,
280 int cpu, u64 timestamp, struct thread *thread)
285 type = trace_parse_common_type(data);
286 event = trace_find_event(type);
288 if (!strcmp(event->name, "kmalloc") ||
289 !strcmp(event->name, "kmem_cache_alloc")) {
290 process_alloc_event(data, event, cpu, timestamp, thread, 0);
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);
300 if (!strcmp(event->name, "kfree") ||
301 !strcmp(event->name, "kmem_cache_free")) {
302 process_free_event(data, event, cpu, timestamp, thread);
307 static int process_sample_event(struct perf_tool *tool __used,
308 union perf_event *event,
309 struct perf_sample *sample,
310 struct perf_evsel *evsel __used,
311 struct machine *machine)
313 struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
315 if (thread == NULL) {
316 pr_debug("problem processing %d event, skipping it.\n",
321 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
323 process_raw_event(event, sample->raw_data, sample->cpu,
324 sample->time, thread);
329 static struct perf_tool perf_kmem = {
330 .sample = process_sample_event,
331 .comm = perf_event__process_comm,
332 .ordered_samples = true,
335 static double fragmentation(unsigned long n_req, unsigned long n_alloc)
340 return 100.0 - (100.0 * n_req / n_alloc);
343 static void __print_result(struct rb_root *root, struct perf_session *session,
344 int n_lines, int is_caller)
346 struct rb_node *next;
347 struct machine *machine;
349 printf("%.102s\n", graph_dotted_line);
350 printf(" %-34s |", is_caller ? "Callsite": "Alloc Ptr");
351 printf(" Total_alloc/Per | Total_req/Per | Hit | Ping-pong | Frag\n");
352 printf("%.102s\n", graph_dotted_line);
354 next = rb_first(root);
356 machine = perf_session__find_host_machine(session);
358 pr_err("__print_result: couldn't find kernel information\n");
361 while (next && n_lines--) {
362 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
364 struct symbol *sym = NULL;
370 addr = data->call_site;
372 sym = machine__find_kernel_function(machine, addr, &map, NULL);
377 snprintf(buf, sizeof(buf), "%s+%" PRIx64 "", sym->name,
378 addr - map->unmap_ip(map, sym->start));
380 snprintf(buf, sizeof(buf), "%#" PRIx64 "", addr);
381 printf(" %-34s |", buf);
383 printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %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));
392 next = rb_next(next);
396 printf(" ... | ... | ... | ... | ... | ... \n");
398 printf("%.102s\n", graph_dotted_line);
401 static void print_summary(void)
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);
413 static void print_result(struct perf_session *session)
416 __print_result(&root_caller_sorted, session, caller_lines, 1);
418 __print_result(&root_alloc_sorted, session, alloc_lines, 0);
422 struct sort_dimension {
425 struct list_head list;
428 static LIST_HEAD(caller_sort);
429 static LIST_HEAD(alloc_sort);
431 static void sort_insert(struct rb_root *root, struct alloc_stat *data,
432 struct list_head *sort_list)
434 struct rb_node **new = &(root->rb_node);
435 struct rb_node *parent = NULL;
436 struct sort_dimension *sort;
439 struct alloc_stat *this;
442 this = rb_entry(*new, struct alloc_stat, node);
445 list_for_each_entry(sort, sort_list, list) {
446 cmp = sort->cmp(data, this);
452 new = &((*new)->rb_left);
454 new = &((*new)->rb_right);
457 rb_link_node(&data->node, parent, new);
458 rb_insert_color(&data->node, root);
461 static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
462 struct list_head *sort_list)
464 struct rb_node *node;
465 struct alloc_stat *data;
468 node = rb_first(root);
472 rb_erase(node, root);
473 data = rb_entry(node, struct alloc_stat, node);
474 sort_insert(root_sorted, data, sort_list);
478 static void sort_result(void)
480 __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
481 __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
484 static int __cmd_kmem(void)
487 struct perf_session *session = perf_session__new(input_name, O_RDONLY,
488 0, false, &perf_kmem);
492 if (perf_session__create_kernel_maps(session) < 0)
495 if (!perf_session__has_traces(session, "kmem record"))
499 err = perf_session__process_events(session, &perf_kmem);
503 print_result(session);
505 perf_session__delete(session);
509 static const char * const kmem_usage[] = {
510 "perf kmem [<options>] {record|stat}",
514 static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r)
518 else if (l->ptr > r->ptr)
523 static struct sort_dimension ptr_sort_dimension = {
528 static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r)
530 if (l->call_site < r->call_site)
532 else if (l->call_site > r->call_site)
537 static struct sort_dimension callsite_sort_dimension = {
542 static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r)
546 else if (l->hit > r->hit)
551 static struct sort_dimension hit_sort_dimension = {
556 static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r)
558 if (l->bytes_alloc < r->bytes_alloc)
560 else if (l->bytes_alloc > r->bytes_alloc)
565 static struct sort_dimension bytes_sort_dimension = {
570 static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r)
574 x = fragmentation(l->bytes_req, l->bytes_alloc);
575 y = fragmentation(r->bytes_req, r->bytes_alloc);
584 static struct sort_dimension frag_sort_dimension = {
589 static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r)
591 if (l->pingpong < r->pingpong)
593 else if (l->pingpong > r->pingpong)
598 static struct sort_dimension pingpong_sort_dimension = {
603 static struct sort_dimension *avail_sorts[] = {
605 &callsite_sort_dimension,
607 &bytes_sort_dimension,
608 &frag_sort_dimension,
609 &pingpong_sort_dimension,
612 #define NUM_AVAIL_SORTS \
613 (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
615 static int sort_dimension__add(const char *tok, struct list_head *list)
617 struct sort_dimension *sort;
620 for (i = 0; i < NUM_AVAIL_SORTS; i++) {
621 if (!strcmp(avail_sorts[i]->name, tok)) {
622 sort = malloc(sizeof(*sort));
625 memcpy(sort, avail_sorts[i], sizeof(*sort));
626 list_add_tail(&sort->list, list);
634 static int setup_sorting(struct list_head *sort_list, const char *arg)
637 char *str = strdup(arg);
643 tok = strsep(&str, ",");
646 if (sort_dimension__add(tok, sort_list) < 0) {
647 error("Unknown --sort key: '%s'", tok);
656 static int parse_sort_opt(const struct option *opt __used,
657 const char *arg, int unset __used)
662 if (caller_flag > alloc_flag)
663 return setup_sorting(&caller_sort, arg);
665 return setup_sorting(&alloc_sort, arg);
670 static int parse_caller_opt(const struct option *opt __used,
671 const char *arg __used, int unset __used)
673 caller_flag = (alloc_flag + 1);
677 static int parse_alloc_opt(const struct option *opt __used,
678 const char *arg __used, int unset __used)
680 alloc_flag = (caller_flag + 1);
684 static int parse_line_opt(const struct option *opt __used,
685 const char *arg, int unset __used)
692 lines = strtoul(arg, NULL, 10);
694 if (caller_flag > alloc_flag)
695 caller_lines = lines;
702 static const struct option kmem_options[] = {
703 OPT_STRING('i', "input", &input_name, "file",
705 OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
706 "show per-callsite statistics",
708 OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
709 "show per-allocation statistics",
711 OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
712 "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
714 OPT_CALLBACK('l', "line", NULL, "num",
717 OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
721 static const char *record_args[] = {
727 "-e", "kmem:kmalloc",
728 "-e", "kmem:kmalloc_node",
730 "-e", "kmem:kmem_cache_alloc",
731 "-e", "kmem:kmem_cache_alloc_node",
732 "-e", "kmem:kmem_cache_free",
735 static int __cmd_record(int argc, const char **argv)
737 unsigned int rec_argc, i, j;
738 const char **rec_argv;
740 rec_argc = ARRAY_SIZE(record_args) + argc - 1;
741 rec_argv = calloc(rec_argc + 1, sizeof(char *));
743 if (rec_argv == NULL)
746 for (i = 0; i < ARRAY_SIZE(record_args); i++)
747 rec_argv[i] = strdup(record_args[i]);
749 for (j = 1; j < (unsigned int)argc; j++, i++)
750 rec_argv[i] = argv[j];
752 return cmd_record(i, rec_argv, NULL);
755 int cmd_kmem(int argc, const char **argv, const char *prefix __used)
757 argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
760 usage_with_options(kmem_usage, kmem_options);
764 if (!strncmp(argv[0], "rec", 3)) {
765 return __cmd_record(argc, argv);
766 } else if (!strcmp(argv[0], "stat")) {
769 if (list_empty(&caller_sort))
770 setup_sorting(&caller_sort, default_sort_order);
771 if (list_empty(&alloc_sort))
772 setup_sorting(&alloc_sort, default_sort_order);
776 usage_with_options(kmem_usage, kmem_options);