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>
19 typedef int (*sort_fn_t
)(struct alloc_stat
*, struct alloc_stat
*);
21 static char const *input_name
= "perf.data";
23 static int alloc_flag
;
24 static int caller_flag
;
26 static int alloc_lines
= -1;
27 static int caller_lines
= -1;
31 static char default_sort_order
[] = "frag,hit,bytes";
33 static int *cpunode_map
;
34 static int max_cpu_num
;
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
;
54 static unsigned long total_requested
, total_allocated
;
55 static unsigned long nr_allocs
, nr_cross_allocs
;
57 #define PATH_SYS_NODE "/sys/devices/system/node"
59 static void init_cpunode_map(void)
64 fp
= fopen("/sys/devices/system/cpu/kernel_max", "r");
70 if (fscanf(fp
, "%d", &max_cpu_num
) < 1)
71 die("Failed to read 'kernel_max' from sysfs");
74 cpunode_map
= calloc(max_cpu_num
, sizeof(int));
77 for (i
= 0; i
< max_cpu_num
; i
++)
82 static void setup_cpunode_map(void)
84 struct dirent
*dent1
, *dent2
;
86 unsigned int cpu
, mem
;
91 dir1
= opendir(PATH_SYS_NODE
);
96 dent1
= readdir(dir1
);
100 if (sscanf(dent1
->d_name
, "node%u", &mem
) < 1)
103 snprintf(buf
, PATH_MAX
, "%s/%s", PATH_SYS_NODE
, dent1
->d_name
);
108 dent2
= readdir(dir2
);
111 if (sscanf(dent2
->d_name
, "cpu%u", &cpu
) < 1)
113 cpunode_map
[cpu
] = mem
;
118 static void insert_alloc_stat(unsigned long call_site
, unsigned long ptr
,
119 int bytes_req
, int bytes_alloc
, int cpu
)
121 struct rb_node
**node
= &root_alloc_stat
.rb_node
;
122 struct rb_node
*parent
= NULL
;
123 struct alloc_stat
*data
= NULL
;
127 data
= rb_entry(*node
, struct alloc_stat
, node
);
130 node
= &(*node
)->rb_right
;
131 else if (ptr
< data
->ptr
)
132 node
= &(*node
)->rb_left
;
137 if (data
&& data
->ptr
== ptr
) {
139 data
->bytes_req
+= bytes_req
;
140 data
->bytes_alloc
+= bytes_alloc
;
142 data
= malloc(sizeof(*data
));
148 data
->bytes_req
= bytes_req
;
149 data
->bytes_alloc
= bytes_alloc
;
151 rb_link_node(&data
->node
, parent
, node
);
152 rb_insert_color(&data
->node
, &root_alloc_stat
);
154 data
->call_site
= call_site
;
155 data
->alloc_cpu
= cpu
;
158 static void insert_caller_stat(unsigned long call_site
,
159 int bytes_req
, int bytes_alloc
)
161 struct rb_node
**node
= &root_caller_stat
.rb_node
;
162 struct rb_node
*parent
= NULL
;
163 struct alloc_stat
*data
= NULL
;
167 data
= rb_entry(*node
, struct alloc_stat
, node
);
169 if (call_site
> data
->call_site
)
170 node
= &(*node
)->rb_right
;
171 else if (call_site
< data
->call_site
)
172 node
= &(*node
)->rb_left
;
177 if (data
&& data
->call_site
== call_site
) {
179 data
->bytes_req
+= bytes_req
;
180 data
->bytes_alloc
+= bytes_alloc
;
182 data
= malloc(sizeof(*data
));
185 data
->call_site
= call_site
;
188 data
->bytes_req
= bytes_req
;
189 data
->bytes_alloc
= bytes_alloc
;
191 rb_link_node(&data
->node
, parent
, node
);
192 rb_insert_color(&data
->node
, &root_caller_stat
);
196 static void process_alloc_event(void *data
,
199 u64 timestamp __used
,
200 struct thread
*thread __used
,
203 unsigned long call_site
;
209 ptr
= raw_field_value(event
, "ptr", data
);
210 call_site
= raw_field_value(event
, "call_site", data
);
211 bytes_req
= raw_field_value(event
, "bytes_req", data
);
212 bytes_alloc
= raw_field_value(event
, "bytes_alloc", data
);
214 insert_alloc_stat(call_site
, ptr
, bytes_req
, bytes_alloc
, cpu
);
215 insert_caller_stat(call_site
, bytes_req
, bytes_alloc
);
217 total_requested
+= bytes_req
;
218 total_allocated
+= bytes_alloc
;
221 node1
= cpunode_map
[cpu
];
222 node2
= raw_field_value(event
, "node", data
);
229 static int ptr_cmp(struct alloc_stat
*, struct alloc_stat
*);
230 static int callsite_cmp(struct alloc_stat
*, struct alloc_stat
*);
232 static struct alloc_stat
*search_alloc_stat(unsigned long ptr
,
233 unsigned long call_site
,
234 struct rb_root
*root
,
237 struct rb_node
*node
= root
->rb_node
;
238 struct alloc_stat key
= { .ptr
= ptr
, .call_site
= call_site
};
241 struct alloc_stat
*data
;
244 data
= rb_entry(node
, struct alloc_stat
, node
);
246 cmp
= sort_fn(&key
, data
);
248 node
= node
->rb_left
;
250 node
= node
->rb_right
;
257 static void process_free_event(void *data
,
260 u64 timestamp __used
,
261 struct thread
*thread __used
)
264 struct alloc_stat
*s_alloc
, *s_caller
;
266 ptr
= raw_field_value(event
, "ptr", data
);
268 s_alloc
= search_alloc_stat(ptr
, 0, &root_alloc_stat
, ptr_cmp
);
272 if (cpu
!= s_alloc
->alloc_cpu
) {
275 s_caller
= search_alloc_stat(0, s_alloc
->call_site
,
276 &root_caller_stat
, callsite_cmp
);
278 s_caller
->pingpong
++;
280 s_alloc
->alloc_cpu
= -1;
284 process_raw_event(event_t
*raw_event __used
, void *data
,
285 int cpu
, u64 timestamp
, struct thread
*thread
)
290 type
= trace_parse_common_type(data
);
291 event
= trace_find_event(type
);
293 if (!strcmp(event
->name
, "kmalloc") ||
294 !strcmp(event
->name
, "kmem_cache_alloc")) {
295 process_alloc_event(data
, event
, cpu
, timestamp
, thread
, 0);
299 if (!strcmp(event
->name
, "kmalloc_node") ||
300 !strcmp(event
->name
, "kmem_cache_alloc_node")) {
301 process_alloc_event(data
, event
, cpu
, timestamp
, thread
, 1);
305 if (!strcmp(event
->name
, "kfree") ||
306 !strcmp(event
->name
, "kmem_cache_free")) {
307 process_free_event(data
, event
, cpu
, timestamp
, thread
);
312 static int process_sample_event(event_t
*event
, struct perf_session
*session
)
314 struct sample_data data
;
315 struct thread
*thread
;
317 memset(&data
, 0, sizeof(data
));
322 event__parse_sample(event
, session
->sample_type
, &data
);
324 dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
327 (void *)(long)data
.ip
,
328 (long long)data
.period
);
330 thread
= perf_session__findnew(session
, event
->ip
.pid
);
331 if (thread
== NULL
) {
332 pr_debug("problem processing %d event, skipping it.\n",
337 dump_printf(" ... thread: %s:%d\n", thread
->comm
, thread
->pid
);
339 process_raw_event(event
, data
.raw_data
, data
.cpu
,
345 static int sample_type_check(struct perf_session
*session
)
347 if (!(session
->sample_type
& PERF_SAMPLE_RAW
)) {
349 "No trace sample to read. Did you call perf record "
357 static struct perf_event_ops event_ops
= {
358 .process_sample_event
= process_sample_event
,
359 .process_comm_event
= event__process_comm
,
360 .sample_type_check
= sample_type_check
,
363 static double fragmentation(unsigned long n_req
, unsigned long n_alloc
)
368 return 100.0 - (100.0 * n_req
/ n_alloc
);
371 static void __print_result(struct rb_root
*root
, struct perf_session
*session
,
372 int n_lines
, int is_caller
)
374 struct rb_node
*next
;
376 printf("%.102s\n", graph_dotted_line
);
377 printf(" %-34s |", is_caller
? "Callsite": "Alloc Ptr");
378 printf(" Total_alloc/Per | Total_req/Per | Hit | Ping-pong | Frag\n");
379 printf("%.102s\n", graph_dotted_line
);
381 next
= rb_first(root
);
383 while (next
&& n_lines
--) {
384 struct alloc_stat
*data
= rb_entry(next
, struct alloc_stat
,
386 struct symbol
*sym
= NULL
;
391 addr
= data
->call_site
;
393 sym
= map_groups__find_function(&session
->kmaps
, session
, addr
, NULL
);
398 snprintf(buf
, sizeof(buf
), "%s+%Lx", sym
->name
,
401 snprintf(buf
, sizeof(buf
), "%#Lx", addr
);
402 printf(" %-34s |", buf
);
404 printf(" %9llu/%-5lu | %9llu/%-5lu | %6lu | %8lu | %6.3f%%\n",
405 (unsigned long long)data
->bytes_alloc
,
406 (unsigned long)data
->bytes_alloc
/ data
->hit
,
407 (unsigned long long)data
->bytes_req
,
408 (unsigned long)data
->bytes_req
/ data
->hit
,
409 (unsigned long)data
->hit
,
410 (unsigned long)data
->pingpong
,
411 fragmentation(data
->bytes_req
, data
->bytes_alloc
));
413 next
= rb_next(next
);
417 printf(" ... | ... | ... | ... | ... | ... \n");
419 printf("%.102s\n", graph_dotted_line
);
422 static void print_summary(void)
424 printf("\nSUMMARY\n=======\n");
425 printf("Total bytes requested: %lu\n", total_requested
);
426 printf("Total bytes allocated: %lu\n", total_allocated
);
427 printf("Total bytes wasted on internal fragmentation: %lu\n",
428 total_allocated
- total_requested
);
429 printf("Internal fragmentation: %f%%\n",
430 fragmentation(total_requested
, total_allocated
));
431 printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs
, nr_allocs
);
434 static void print_result(struct perf_session
*session
)
437 __print_result(&root_caller_sorted
, session
, caller_lines
, 1);
439 __print_result(&root_alloc_sorted
, session
, alloc_lines
, 0);
443 struct sort_dimension
{
446 struct list_head list
;
449 static LIST_HEAD(caller_sort
);
450 static LIST_HEAD(alloc_sort
);
452 static void sort_insert(struct rb_root
*root
, struct alloc_stat
*data
,
453 struct list_head
*sort_list
)
455 struct rb_node
**new = &(root
->rb_node
);
456 struct rb_node
*parent
= NULL
;
457 struct sort_dimension
*sort
;
460 struct alloc_stat
*this;
463 this = rb_entry(*new, struct alloc_stat
, node
);
466 list_for_each_entry(sort
, sort_list
, list
) {
467 cmp
= sort
->cmp(data
, this);
473 new = &((*new)->rb_left
);
475 new = &((*new)->rb_right
);
478 rb_link_node(&data
->node
, parent
, new);
479 rb_insert_color(&data
->node
, root
);
482 static void __sort_result(struct rb_root
*root
, struct rb_root
*root_sorted
,
483 struct list_head
*sort_list
)
485 struct rb_node
*node
;
486 struct alloc_stat
*data
;
489 node
= rb_first(root
);
493 rb_erase(node
, root
);
494 data
= rb_entry(node
, struct alloc_stat
, node
);
495 sort_insert(root_sorted
, data
, sort_list
);
499 static void sort_result(void)
501 __sort_result(&root_alloc_stat
, &root_alloc_sorted
, &alloc_sort
);
502 __sort_result(&root_caller_stat
, &root_caller_sorted
, &caller_sort
);
505 static int __cmd_kmem(void)
508 struct perf_session
*session
= perf_session__new(input_name
, O_RDONLY
, 0);
513 err
= perf_session__process_events(session
, &event_ops
);
517 print_result(session
);
519 perf_session__delete(session
);
523 static const char * const kmem_usage
[] = {
524 "perf kmem [<options>] {record|stat}",
528 static int ptr_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
532 else if (l
->ptr
> r
->ptr
)
537 static struct sort_dimension ptr_sort_dimension
= {
542 static int callsite_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
544 if (l
->call_site
< r
->call_site
)
546 else if (l
->call_site
> r
->call_site
)
551 static struct sort_dimension callsite_sort_dimension
= {
556 static int hit_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
560 else if (l
->hit
> r
->hit
)
565 static struct sort_dimension hit_sort_dimension
= {
570 static int bytes_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
572 if (l
->bytes_alloc
< r
->bytes_alloc
)
574 else if (l
->bytes_alloc
> r
->bytes_alloc
)
579 static struct sort_dimension bytes_sort_dimension
= {
584 static int frag_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
588 x
= fragmentation(l
->bytes_req
, l
->bytes_alloc
);
589 y
= fragmentation(r
->bytes_req
, r
->bytes_alloc
);
598 static struct sort_dimension frag_sort_dimension
= {
603 static int pingpong_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
605 if (l
->pingpong
< r
->pingpong
)
607 else if (l
->pingpong
> r
->pingpong
)
612 static struct sort_dimension pingpong_sort_dimension
= {
617 static struct sort_dimension
*avail_sorts
[] = {
619 &callsite_sort_dimension
,
621 &bytes_sort_dimension
,
622 &frag_sort_dimension
,
623 &pingpong_sort_dimension
,
626 #define NUM_AVAIL_SORTS \
627 (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
629 static int sort_dimension__add(const char *tok
, struct list_head
*list
)
631 struct sort_dimension
*sort
;
634 for (i
= 0; i
< NUM_AVAIL_SORTS
; i
++) {
635 if (!strcmp(avail_sorts
[i
]->name
, tok
)) {
636 sort
= malloc(sizeof(*sort
));
639 memcpy(sort
, avail_sorts
[i
], sizeof(*sort
));
640 list_add_tail(&sort
->list
, list
);
648 static int setup_sorting(struct list_head
*sort_list
, const char *arg
)
651 char *str
= strdup(arg
);
657 tok
= strsep(&str
, ",");
660 if (sort_dimension__add(tok
, sort_list
) < 0) {
661 error("Unknown --sort key: '%s'", tok
);
670 static int parse_sort_opt(const struct option
*opt __used
,
671 const char *arg
, int unset __used
)
676 if (caller_flag
> alloc_flag
)
677 return setup_sorting(&caller_sort
, arg
);
679 return setup_sorting(&alloc_sort
, arg
);
684 static int parse_caller_opt(const struct option
*opt __used
,
685 const char *arg __used
, int unset __used
)
687 caller_flag
= (alloc_flag
+ 1);
691 static int parse_alloc_opt(const struct option
*opt __used
,
692 const char *arg __used
, int unset __used
)
694 alloc_flag
= (caller_flag
+ 1);
698 static int parse_line_opt(const struct option
*opt __used
,
699 const char *arg
, int unset __used
)
706 lines
= strtoul(arg
, NULL
, 10);
708 if (caller_flag
> alloc_flag
)
709 caller_lines
= lines
;
716 static const struct option kmem_options
[] = {
717 OPT_STRING('i', "input", &input_name
, "file",
719 OPT_CALLBACK_NOOPT(0, "caller", NULL
, NULL
,
720 "show per-callsite statistics",
722 OPT_CALLBACK_NOOPT(0, "alloc", NULL
, NULL
,
723 "show per-allocation statistics",
725 OPT_CALLBACK('s', "sort", NULL
, "key[,key2...]",
726 "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
728 OPT_CALLBACK('l', "line", NULL
, "num",
731 OPT_BOOLEAN(0, "raw-ip", &raw_ip
, "show raw ip instead of symbol"),
735 static const char *record_args
[] = {
742 "-e", "kmem:kmalloc",
743 "-e", "kmem:kmalloc_node",
745 "-e", "kmem:kmem_cache_alloc",
746 "-e", "kmem:kmem_cache_alloc_node",
747 "-e", "kmem:kmem_cache_free",
750 static int __cmd_record(int argc
, const char **argv
)
752 unsigned int rec_argc
, i
, j
;
753 const char **rec_argv
;
755 rec_argc
= ARRAY_SIZE(record_args
) + argc
- 1;
756 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
758 for (i
= 0; i
< ARRAY_SIZE(record_args
); i
++)
759 rec_argv
[i
] = strdup(record_args
[i
]);
761 for (j
= 1; j
< (unsigned int)argc
; j
++, i
++)
762 rec_argv
[i
] = argv
[j
];
764 return cmd_record(i
, rec_argv
, NULL
);
767 int cmd_kmem(int argc
, const char **argv
, const char *prefix __used
)
769 argc
= parse_options(argc
, argv
, kmem_options
, kmem_usage
, 0);
772 usage_with_options(kmem_usage
, kmem_options
);
776 if (!strncmp(argv
[0], "rec", 3)) {
777 return __cmd_record(argc
, argv
);
778 } else if (!strcmp(argv
[0], "stat")) {
781 if (list_empty(&caller_sort
))
782 setup_sorting(&caller_sort
, default_sort_order
);
783 if (list_empty(&alloc_sort
))
784 setup_sorting(&alloc_sort
, default_sort_order
);