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 const char *input_name;
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;
116 static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
117 int bytes_req, int bytes_alloc, int cpu)
119 struct rb_node **node = &root_alloc_stat.rb_node;
120 struct rb_node *parent = NULL;
121 struct alloc_stat *data = NULL;
125 data = rb_entry(*node, struct alloc_stat, node);
128 node = &(*node)->rb_right;
129 else if (ptr < data->ptr)
130 node = &(*node)->rb_left;
135 if (data && data->ptr == ptr) {
137 data->bytes_req += bytes_req;
138 data->bytes_alloc += bytes_alloc;
140 data = malloc(sizeof(*data));
146 data->bytes_req = bytes_req;
147 data->bytes_alloc = bytes_alloc;
149 rb_link_node(&data->node, parent, node);
150 rb_insert_color(&data->node, &root_alloc_stat);
152 data->call_site = call_site;
153 data->alloc_cpu = cpu;
156 static void insert_caller_stat(unsigned long call_site,
157 int bytes_req, int bytes_alloc)
159 struct rb_node **node = &root_caller_stat.rb_node;
160 struct rb_node *parent = NULL;
161 struct alloc_stat *data = NULL;
165 data = rb_entry(*node, struct alloc_stat, node);
167 if (call_site > data->call_site)
168 node = &(*node)->rb_right;
169 else if (call_site < data->call_site)
170 node = &(*node)->rb_left;
175 if (data && data->call_site == call_site) {
177 data->bytes_req += bytes_req;
178 data->bytes_alloc += bytes_alloc;
180 data = malloc(sizeof(*data));
183 data->call_site = call_site;
186 data->bytes_req = bytes_req;
187 data->bytes_alloc = bytes_alloc;
189 rb_link_node(&data->node, parent, node);
190 rb_insert_color(&data->node, &root_caller_stat);
194 static void process_alloc_event(void *data,
197 u64 timestamp __used,
198 struct thread *thread __used,
201 unsigned long call_site;
207 ptr = raw_field_value(event, "ptr", data);
208 call_site = raw_field_value(event, "call_site", data);
209 bytes_req = raw_field_value(event, "bytes_req", data);
210 bytes_alloc = raw_field_value(event, "bytes_alloc", data);
212 insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
213 insert_caller_stat(call_site, bytes_req, bytes_alloc);
215 total_requested += bytes_req;
216 total_allocated += bytes_alloc;
219 node1 = cpunode_map[cpu];
220 node2 = raw_field_value(event, "node", data);
227 static int ptr_cmp(struct alloc_stat *, struct alloc_stat *);
228 static int callsite_cmp(struct alloc_stat *, struct alloc_stat *);
230 static struct alloc_stat *search_alloc_stat(unsigned long ptr,
231 unsigned long call_site,
232 struct rb_root *root,
235 struct rb_node *node = root->rb_node;
236 struct alloc_stat key = { .ptr = ptr, .call_site = call_site };
239 struct alloc_stat *data;
242 data = rb_entry(node, struct alloc_stat, node);
244 cmp = sort_fn(&key, data);
246 node = node->rb_left;
248 node = node->rb_right;
255 static void process_free_event(void *data,
258 u64 timestamp __used,
259 struct thread *thread __used)
262 struct alloc_stat *s_alloc, *s_caller;
264 ptr = raw_field_value(event, "ptr", data);
266 s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp);
270 if (cpu != s_alloc->alloc_cpu) {
273 s_caller = search_alloc_stat(0, s_alloc->call_site,
274 &root_caller_stat, callsite_cmp);
276 s_caller->pingpong++;
278 s_alloc->alloc_cpu = -1;
281 static void process_raw_event(union perf_event *raw_event __used, void *data,
282 int cpu, u64 timestamp, struct thread *thread)
287 type = trace_parse_common_type(data);
288 event = trace_find_event(type);
290 if (!strcmp(event->name, "kmalloc") ||
291 !strcmp(event->name, "kmem_cache_alloc")) {
292 process_alloc_event(data, event, cpu, timestamp, thread, 0);
296 if (!strcmp(event->name, "kmalloc_node") ||
297 !strcmp(event->name, "kmem_cache_alloc_node")) {
298 process_alloc_event(data, event, cpu, timestamp, thread, 1);
302 if (!strcmp(event->name, "kfree") ||
303 !strcmp(event->name, "kmem_cache_free")) {
304 process_free_event(data, event, cpu, timestamp, thread);
309 static int process_sample_event(struct perf_tool *tool __used,
310 union perf_event *event,
311 struct perf_sample *sample,
312 struct perf_evsel *evsel __used,
313 struct machine *machine)
315 struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
317 if (thread == NULL) {
318 pr_debug("problem processing %d event, skipping it.\n",
323 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
325 process_raw_event(event, sample->raw_data, sample->cpu,
326 sample->time, thread);
331 static struct perf_tool perf_kmem = {
332 .sample = process_sample_event,
333 .comm = perf_event__process_comm,
334 .ordered_samples = true,
337 static double fragmentation(unsigned long n_req, unsigned long n_alloc)
342 return 100.0 - (100.0 * n_req / n_alloc);
345 static void __print_result(struct rb_root *root, struct perf_session *session,
346 int n_lines, int is_caller)
348 struct rb_node *next;
349 struct machine *machine;
351 printf("%.102s\n", graph_dotted_line);
352 printf(" %-34s |", is_caller ? "Callsite": "Alloc Ptr");
353 printf(" Total_alloc/Per | Total_req/Per | Hit | Ping-pong | Frag\n");
354 printf("%.102s\n", graph_dotted_line);
356 next = rb_first(root);
358 machine = perf_session__find_host_machine(session);
360 pr_err("__print_result: couldn't find kernel information\n");
363 while (next && n_lines--) {
364 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
366 struct symbol *sym = NULL;
372 addr = data->call_site;
374 sym = machine__find_kernel_function(machine, addr, &map, NULL);
379 snprintf(buf, sizeof(buf), "%s+%" PRIx64 "", sym->name,
380 addr - map->unmap_ip(map, sym->start));
382 snprintf(buf, sizeof(buf), "%#" PRIx64 "", addr);
383 printf(" %-34s |", buf);
385 printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %8lu | %6.3f%%\n",
386 (unsigned long long)data->bytes_alloc,
387 (unsigned long)data->bytes_alloc / data->hit,
388 (unsigned long long)data->bytes_req,
389 (unsigned long)data->bytes_req / data->hit,
390 (unsigned long)data->hit,
391 (unsigned long)data->pingpong,
392 fragmentation(data->bytes_req, data->bytes_alloc));
394 next = rb_next(next);
398 printf(" ... | ... | ... | ... | ... | ... \n");
400 printf("%.102s\n", graph_dotted_line);
403 static void print_summary(void)
405 printf("\nSUMMARY\n=======\n");
406 printf("Total bytes requested: %lu\n", total_requested);
407 printf("Total bytes allocated: %lu\n", total_allocated);
408 printf("Total bytes wasted on internal fragmentation: %lu\n",
409 total_allocated - total_requested);
410 printf("Internal fragmentation: %f%%\n",
411 fragmentation(total_requested, total_allocated));
412 printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
415 static void print_result(struct perf_session *session)
418 __print_result(&root_caller_sorted, session, caller_lines, 1);
420 __print_result(&root_alloc_sorted, session, alloc_lines, 0);
424 struct sort_dimension {
427 struct list_head list;
430 static LIST_HEAD(caller_sort);
431 static LIST_HEAD(alloc_sort);
433 static void sort_insert(struct rb_root *root, struct alloc_stat *data,
434 struct list_head *sort_list)
436 struct rb_node **new = &(root->rb_node);
437 struct rb_node *parent = NULL;
438 struct sort_dimension *sort;
441 struct alloc_stat *this;
444 this = rb_entry(*new, struct alloc_stat, node);
447 list_for_each_entry(sort, sort_list, list) {
448 cmp = sort->cmp(data, this);
454 new = &((*new)->rb_left);
456 new = &((*new)->rb_right);
459 rb_link_node(&data->node, parent, new);
460 rb_insert_color(&data->node, root);
463 static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
464 struct list_head *sort_list)
466 struct rb_node *node;
467 struct alloc_stat *data;
470 node = rb_first(root);
474 rb_erase(node, root);
475 data = rb_entry(node, struct alloc_stat, node);
476 sort_insert(root_sorted, data, sort_list);
480 static void sort_result(void)
482 __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
483 __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
486 static int __cmd_kmem(void)
489 struct perf_session *session = perf_session__new(input_name, O_RDONLY,
490 0, false, &perf_kmem);
494 if (perf_session__create_kernel_maps(session) < 0)
497 if (!perf_session__has_traces(session, "kmem record"))
501 err = perf_session__process_events(session, &perf_kmem);
505 print_result(session);
507 perf_session__delete(session);
511 static const char * const kmem_usage[] = {
512 "perf kmem [<options>] {record|stat}",
516 static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r)
520 else if (l->ptr > r->ptr)
525 static struct sort_dimension ptr_sort_dimension = {
530 static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r)
532 if (l->call_site < r->call_site)
534 else if (l->call_site > r->call_site)
539 static struct sort_dimension callsite_sort_dimension = {
544 static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r)
548 else if (l->hit > r->hit)
553 static struct sort_dimension hit_sort_dimension = {
558 static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r)
560 if (l->bytes_alloc < r->bytes_alloc)
562 else if (l->bytes_alloc > r->bytes_alloc)
567 static struct sort_dimension bytes_sort_dimension = {
572 static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r)
576 x = fragmentation(l->bytes_req, l->bytes_alloc);
577 y = fragmentation(r->bytes_req, r->bytes_alloc);
586 static struct sort_dimension frag_sort_dimension = {
591 static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r)
593 if (l->pingpong < r->pingpong)
595 else if (l->pingpong > r->pingpong)
600 static struct sort_dimension pingpong_sort_dimension = {
605 static struct sort_dimension *avail_sorts[] = {
607 &callsite_sort_dimension,
609 &bytes_sort_dimension,
610 &frag_sort_dimension,
611 &pingpong_sort_dimension,
614 #define NUM_AVAIL_SORTS \
615 (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
617 static int sort_dimension__add(const char *tok, struct list_head *list)
619 struct sort_dimension *sort;
622 for (i = 0; i < NUM_AVAIL_SORTS; i++) {
623 if (!strcmp(avail_sorts[i]->name, tok)) {
624 sort = malloc(sizeof(*sort));
627 memcpy(sort, avail_sorts[i], sizeof(*sort));
628 list_add_tail(&sort->list, list);
636 static int setup_sorting(struct list_head *sort_list, const char *arg)
639 char *str = strdup(arg);
645 tok = strsep(&str, ",");
648 if (sort_dimension__add(tok, sort_list) < 0) {
649 error("Unknown --sort key: '%s'", tok);
659 static int parse_sort_opt(const struct option *opt __used,
660 const char *arg, int unset __used)
665 if (caller_flag > alloc_flag)
666 return setup_sorting(&caller_sort, arg);
668 return setup_sorting(&alloc_sort, arg);
673 static int parse_caller_opt(const struct option *opt __used,
674 const char *arg __used, int unset __used)
676 caller_flag = (alloc_flag + 1);
680 static int parse_alloc_opt(const struct option *opt __used,
681 const char *arg __used, int unset __used)
683 alloc_flag = (caller_flag + 1);
687 static int parse_line_opt(const struct option *opt __used,
688 const char *arg, int unset __used)
695 lines = strtoul(arg, NULL, 10);
697 if (caller_flag > alloc_flag)
698 caller_lines = lines;
705 static const struct option kmem_options[] = {
706 OPT_STRING('i', "input", &input_name, "file",
708 OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
709 "show per-callsite statistics",
711 OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
712 "show per-allocation statistics",
714 OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
715 "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
717 OPT_CALLBACK('l', "line", NULL, "num",
720 OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
724 static const char *record_args[] = {
730 "-e", "kmem:kmalloc",
731 "-e", "kmem:kmalloc_node",
733 "-e", "kmem:kmem_cache_alloc",
734 "-e", "kmem:kmem_cache_alloc_node",
735 "-e", "kmem:kmem_cache_free",
738 static int __cmd_record(int argc, const char **argv)
740 unsigned int rec_argc, i, j;
741 const char **rec_argv;
743 rec_argc = ARRAY_SIZE(record_args) + argc - 1;
744 rec_argv = calloc(rec_argc + 1, sizeof(char *));
746 if (rec_argv == NULL)
749 for (i = 0; i < ARRAY_SIZE(record_args); i++)
750 rec_argv[i] = strdup(record_args[i]);
752 for (j = 1; j < (unsigned int)argc; j++, i++)
753 rec_argv[i] = argv[j];
755 return cmd_record(i, rec_argv, NULL);
758 int cmd_kmem(int argc, const char **argv, const char *prefix __used)
760 argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
763 usage_with_options(kmem_usage, kmem_options);
767 if (!strncmp(argv[0], "rec", 3)) {
768 return __cmd_record(argc, argv);
769 } else if (!strcmp(argv[0], "stat")) {
772 if (list_empty(&caller_sort))
773 setup_sorting(&caller_sort, default_sort_order);
774 if (list_empty(&alloc_sort))
775 setup_sorting(&alloc_sort, default_sort_order);
779 usage_with_options(kmem_usage, kmem_options);