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"
11 #include "util/parse-options.h"
12 #include "util/trace-event.h"
14 #include "util/debug.h"
16 #include <linux/rbtree.h>
17 #include <linux/slab.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;
280 process_raw_event(event_t *raw_event __used, void *data,
281 int cpu, u64 timestamp, struct thread *thread)
286 type = trace_parse_common_type(data);
287 event = trace_find_event(type);
289 if (!strcmp(event->name, "kmalloc") ||
290 !strcmp(event->name, "kmem_cache_alloc")) {
291 process_alloc_event(data, event, cpu, timestamp, thread, 0);
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);
301 if (!strcmp(event->name, "kfree") ||
302 !strcmp(event->name, "kmem_cache_free")) {
303 process_free_event(data, event, cpu, timestamp, thread);
308 static int process_sample_event(event_t *event, struct perf_session *session)
310 struct sample_data data;
311 struct thread *thread;
313 memset(&data, 0, sizeof(data));
318 event__parse_sample(event, session->sample_type, &data);
320 dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
321 data.pid, data.tid, data.ip, data.period);
323 thread = perf_session__findnew(session, event->ip.pid);
324 if (thread == NULL) {
325 pr_debug("problem processing %d event, skipping it.\n",
330 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
332 process_raw_event(event, data.raw_data, data.cpu,
338 static struct perf_event_ops event_ops = {
339 .sample = process_sample_event,
340 .comm = event__process_comm,
343 static double fragmentation(unsigned long n_req, unsigned long n_alloc)
348 return 100.0 - (100.0 * n_req / n_alloc);
351 static void __print_result(struct rb_root *root, struct perf_session *session,
352 int n_lines, int is_caller)
354 struct rb_node *next;
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);
361 next = rb_first(root);
363 while (next && n_lines--) {
364 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
366 struct symbol *sym = NULL;
371 addr = data->call_site;
373 sym = map_groups__find_function(&session->kmaps, addr, NULL);
378 snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
381 snprintf(buf, sizeof(buf), "%#Lx", addr);
382 printf(" %-34s |", buf);
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));
393 next = rb_next(next);
397 printf(" ... | ... | ... | ... | ... | ... \n");
399 printf("%.102s\n", graph_dotted_line);
402 static void print_summary(void)
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);
414 static void print_result(struct perf_session *session)
417 __print_result(&root_caller_sorted, session, caller_lines, 1);
419 __print_result(&root_alloc_sorted, session, alloc_lines, 0);
423 struct sort_dimension {
426 struct list_head list;
429 static LIST_HEAD(caller_sort);
430 static LIST_HEAD(alloc_sort);
432 static void sort_insert(struct rb_root *root, struct alloc_stat *data,
433 struct list_head *sort_list)
435 struct rb_node **new = &(root->rb_node);
436 struct rb_node *parent = NULL;
437 struct sort_dimension *sort;
440 struct alloc_stat *this;
443 this = rb_entry(*new, struct alloc_stat, node);
446 list_for_each_entry(sort, sort_list, list) {
447 cmp = sort->cmp(data, this);
453 new = &((*new)->rb_left);
455 new = &((*new)->rb_right);
458 rb_link_node(&data->node, parent, new);
459 rb_insert_color(&data->node, root);
462 static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
463 struct list_head *sort_list)
465 struct rb_node *node;
466 struct alloc_stat *data;
469 node = rb_first(root);
473 rb_erase(node, root);
474 data = rb_entry(node, struct alloc_stat, node);
475 sort_insert(root_sorted, data, sort_list);
479 static void sort_result(void)
481 __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
482 __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
485 static int __cmd_kmem(void)
488 struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
492 if (!perf_session__has_traces(session, "kmem record"))
496 err = perf_session__process_events(session, &event_ops);
500 print_result(session);
502 perf_session__delete(session);
506 static const char * const kmem_usage[] = {
507 "perf kmem [<options>] {record|stat}",
511 static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r)
515 else if (l->ptr > r->ptr)
520 static struct sort_dimension ptr_sort_dimension = {
525 static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r)
527 if (l->call_site < r->call_site)
529 else if (l->call_site > r->call_site)
534 static struct sort_dimension callsite_sort_dimension = {
539 static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r)
543 else if (l->hit > r->hit)
548 static struct sort_dimension hit_sort_dimension = {
553 static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r)
555 if (l->bytes_alloc < r->bytes_alloc)
557 else if (l->bytes_alloc > r->bytes_alloc)
562 static struct sort_dimension bytes_sort_dimension = {
567 static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r)
571 x = fragmentation(l->bytes_req, l->bytes_alloc);
572 y = fragmentation(r->bytes_req, r->bytes_alloc);
581 static struct sort_dimension frag_sort_dimension = {
586 static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r)
588 if (l->pingpong < r->pingpong)
590 else if (l->pingpong > r->pingpong)
595 static struct sort_dimension pingpong_sort_dimension = {
600 static struct sort_dimension *avail_sorts[] = {
602 &callsite_sort_dimension,
604 &bytes_sort_dimension,
605 &frag_sort_dimension,
606 &pingpong_sort_dimension,
609 #define NUM_AVAIL_SORTS \
610 (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
612 static int sort_dimension__add(const char *tok, struct list_head *list)
614 struct sort_dimension *sort;
617 for (i = 0; i < NUM_AVAIL_SORTS; i++) {
618 if (!strcmp(avail_sorts[i]->name, tok)) {
619 sort = malloc(sizeof(*sort));
622 memcpy(sort, avail_sorts[i], sizeof(*sort));
623 list_add_tail(&sort->list, list);
631 static int setup_sorting(struct list_head *sort_list, const char *arg)
634 char *str = strdup(arg);
640 tok = strsep(&str, ",");
643 if (sort_dimension__add(tok, sort_list) < 0) {
644 error("Unknown --sort key: '%s'", tok);
653 static int parse_sort_opt(const struct option *opt __used,
654 const char *arg, int unset __used)
659 if (caller_flag > alloc_flag)
660 return setup_sorting(&caller_sort, arg);
662 return setup_sorting(&alloc_sort, arg);
667 static int parse_caller_opt(const struct option *opt __used,
668 const char *arg __used, int unset __used)
670 caller_flag = (alloc_flag + 1);
674 static int parse_alloc_opt(const struct option *opt __used,
675 const char *arg __used, int unset __used)
677 alloc_flag = (caller_flag + 1);
681 static int parse_line_opt(const struct option *opt __used,
682 const char *arg, int unset __used)
689 lines = strtoul(arg, NULL, 10);
691 if (caller_flag > alloc_flag)
692 caller_lines = lines;
699 static const struct option kmem_options[] = {
700 OPT_STRING('i', "input", &input_name, "file",
702 OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
703 "show per-callsite statistics",
705 OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
706 "show per-allocation statistics",
708 OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
709 "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
711 OPT_CALLBACK('l', "line", NULL, "num",
714 OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
718 static const char *record_args[] = {
725 "-e", "kmem:kmalloc",
726 "-e", "kmem:kmalloc_node",
728 "-e", "kmem:kmem_cache_alloc",
729 "-e", "kmem:kmem_cache_alloc_node",
730 "-e", "kmem:kmem_cache_free",
733 static int __cmd_record(int argc, const char **argv)
735 unsigned int rec_argc, i, j;
736 const char **rec_argv;
738 rec_argc = ARRAY_SIZE(record_args) + argc - 1;
739 rec_argv = calloc(rec_argc + 1, sizeof(char *));
741 for (i = 0; i < ARRAY_SIZE(record_args); i++)
742 rec_argv[i] = strdup(record_args[i]);
744 for (j = 1; j < (unsigned int)argc; j++, i++)
745 rec_argv[i] = argv[j];
747 return cmd_record(i, rec_argv, NULL);
750 int cmd_kmem(int argc, const char **argv, const char *prefix __used)
752 argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
755 usage_with_options(kmem_usage, kmem_options);
759 if (!strncmp(argv[0], "rec", 3)) {
760 return __cmd_record(argc, argv);
761 } else if (!strcmp(argv[0], "stat")) {
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);
771 usage_with_options(kmem_usage, kmem_options);