4 #include "util/evlist.h"
5 #include "util/evsel.h"
7 #include "util/cache.h"
8 #include "util/symbol.h"
9 #include "util/thread.h"
10 #include "util/header.h"
11 #include "util/session.h"
12 #include "util/tool.h"
14 #include "util/parse-options.h"
15 #include "util/trace-event.h"
17 #include "util/debug.h"
19 #include <linux/rbtree.h>
22 typedef int (*sort_fn_t
)(struct alloc_stat
*, struct alloc_stat
*);
24 static int alloc_flag
;
25 static int caller_flag
;
27 static int alloc_lines
= -1;
28 static int caller_lines
= -1;
32 static int *cpunode_map
;
33 static int max_cpu_num
;
48 static struct rb_root root_alloc_stat
;
49 static struct rb_root root_alloc_sorted
;
50 static struct rb_root root_caller_stat
;
51 static struct rb_root root_caller_sorted
;
53 static unsigned long total_requested
, total_allocated
;
54 static unsigned long nr_allocs
, nr_cross_allocs
;
56 #define PATH_SYS_NODE "/sys/devices/system/node"
58 static int init_cpunode_map(void)
63 fp
= fopen("/sys/devices/system/cpu/kernel_max", "r");
69 if (fscanf(fp
, "%d", &max_cpu_num
) < 1) {
70 pr_err("Failed to read 'kernel_max' from sysfs");
76 cpunode_map
= calloc(max_cpu_num
, sizeof(int));
78 pr_err("%s: calloc failed\n", __func__
);
82 for (i
= 0; i
< max_cpu_num
; i
++)
91 static int setup_cpunode_map(void)
93 struct dirent
*dent1
, *dent2
;
95 unsigned int cpu
, mem
;
98 if (init_cpunode_map())
101 dir1
= opendir(PATH_SYS_NODE
);
105 while ((dent1
= readdir(dir1
)) != NULL
) {
106 if (dent1
->d_type
!= DT_DIR
||
107 sscanf(dent1
->d_name
, "node%u", &mem
) < 1)
110 snprintf(buf
, PATH_MAX
, "%s/%s", PATH_SYS_NODE
, dent1
->d_name
);
114 while ((dent2
= readdir(dir2
)) != NULL
) {
115 if (dent2
->d_type
!= DT_LNK
||
116 sscanf(dent2
->d_name
, "cpu%u", &cpu
) < 1)
118 cpunode_map
[cpu
] = mem
;
126 static int insert_alloc_stat(unsigned long call_site
, unsigned long ptr
,
127 int bytes_req
, int bytes_alloc
, int cpu
)
129 struct rb_node
**node
= &root_alloc_stat
.rb_node
;
130 struct rb_node
*parent
= NULL
;
131 struct alloc_stat
*data
= NULL
;
135 data
= rb_entry(*node
, struct alloc_stat
, node
);
138 node
= &(*node
)->rb_right
;
139 else if (ptr
< data
->ptr
)
140 node
= &(*node
)->rb_left
;
145 if (data
&& data
->ptr
== ptr
) {
147 data
->bytes_req
+= bytes_req
;
148 data
->bytes_alloc
+= bytes_alloc
;
150 data
= malloc(sizeof(*data
));
152 pr_err("%s: malloc failed\n", __func__
);
158 data
->bytes_req
= bytes_req
;
159 data
->bytes_alloc
= bytes_alloc
;
161 rb_link_node(&data
->node
, parent
, node
);
162 rb_insert_color(&data
->node
, &root_alloc_stat
);
164 data
->call_site
= call_site
;
165 data
->alloc_cpu
= cpu
;
169 static int insert_caller_stat(unsigned long call_site
,
170 int bytes_req
, int bytes_alloc
)
172 struct rb_node
**node
= &root_caller_stat
.rb_node
;
173 struct rb_node
*parent
= NULL
;
174 struct alloc_stat
*data
= NULL
;
178 data
= rb_entry(*node
, struct alloc_stat
, node
);
180 if (call_site
> data
->call_site
)
181 node
= &(*node
)->rb_right
;
182 else if (call_site
< data
->call_site
)
183 node
= &(*node
)->rb_left
;
188 if (data
&& data
->call_site
== call_site
) {
190 data
->bytes_req
+= bytes_req
;
191 data
->bytes_alloc
+= bytes_alloc
;
193 data
= malloc(sizeof(*data
));
195 pr_err("%s: malloc failed\n", __func__
);
198 data
->call_site
= call_site
;
201 data
->bytes_req
= bytes_req
;
202 data
->bytes_alloc
= bytes_alloc
;
204 rb_link_node(&data
->node
, parent
, node
);
205 rb_insert_color(&data
->node
, &root_caller_stat
);
211 static int perf_evsel__process_alloc_event(struct perf_evsel
*evsel
,
212 struct perf_sample
*sample
)
214 unsigned long ptr
= perf_evsel__intval(evsel
, sample
, "ptr"),
215 call_site
= perf_evsel__intval(evsel
, sample
, "call_site");
216 int bytes_req
= perf_evsel__intval(evsel
, sample
, "bytes_req"),
217 bytes_alloc
= perf_evsel__intval(evsel
, sample
, "bytes_alloc");
219 if (insert_alloc_stat(call_site
, ptr
, bytes_req
, bytes_alloc
, sample
->cpu
) ||
220 insert_caller_stat(call_site
, bytes_req
, bytes_alloc
))
223 total_requested
+= bytes_req
;
224 total_allocated
+= bytes_alloc
;
230 static int perf_evsel__process_alloc_node_event(struct perf_evsel
*evsel
,
231 struct perf_sample
*sample
)
233 int ret
= perf_evsel__process_alloc_event(evsel
, sample
);
236 int node1
= cpunode_map
[sample
->cpu
],
237 node2
= perf_evsel__intval(evsel
, sample
, "node");
246 static int ptr_cmp(struct alloc_stat
*, struct alloc_stat
*);
247 static int callsite_cmp(struct alloc_stat
*, struct alloc_stat
*);
249 static struct alloc_stat
*search_alloc_stat(unsigned long ptr
,
250 unsigned long call_site
,
251 struct rb_root
*root
,
254 struct rb_node
*node
= root
->rb_node
;
255 struct alloc_stat key
= { .ptr
= ptr
, .call_site
= call_site
};
258 struct alloc_stat
*data
;
261 data
= rb_entry(node
, struct alloc_stat
, node
);
263 cmp
= sort_fn(&key
, data
);
265 node
= node
->rb_left
;
267 node
= node
->rb_right
;
274 static int perf_evsel__process_free_event(struct perf_evsel
*evsel
,
275 struct perf_sample
*sample
)
277 unsigned long ptr
= perf_evsel__intval(evsel
, sample
, "ptr");
278 struct alloc_stat
*s_alloc
, *s_caller
;
280 s_alloc
= search_alloc_stat(ptr
, 0, &root_alloc_stat
, ptr_cmp
);
284 if ((short)sample
->cpu
!= s_alloc
->alloc_cpu
) {
287 s_caller
= search_alloc_stat(0, s_alloc
->call_site
,
288 &root_caller_stat
, callsite_cmp
);
291 s_caller
->pingpong
++;
293 s_alloc
->alloc_cpu
= -1;
298 typedef int (*tracepoint_handler
)(struct perf_evsel
*evsel
,
299 struct perf_sample
*sample
);
301 static int process_sample_event(struct perf_tool
*tool __maybe_unused
,
302 union perf_event
*event
,
303 struct perf_sample
*sample
,
304 struct perf_evsel
*evsel
,
305 struct machine
*machine
)
307 struct thread
*thread
= machine__findnew_thread(machine
, event
->ip
.pid
);
309 if (thread
== NULL
) {
310 pr_debug("problem processing %d event, skipping it.\n",
315 dump_printf(" ... thread: %s:%d\n", thread
->comm
, thread
->pid
);
317 if (evsel
->handler
.func
!= NULL
) {
318 tracepoint_handler f
= evsel
->handler
.func
;
319 return f(evsel
, sample
);
325 static struct perf_tool perf_kmem
= {
326 .sample
= process_sample_event
,
327 .comm
= perf_event__process_comm
,
328 .ordered_samples
= true,
331 static double fragmentation(unsigned long n_req
, unsigned long n_alloc
)
336 return 100.0 - (100.0 * n_req
/ n_alloc
);
339 static void __print_result(struct rb_root
*root
, struct perf_session
*session
,
340 int n_lines
, int is_caller
)
342 struct rb_node
*next
;
343 struct machine
*machine
;
345 printf("%.102s\n", graph_dotted_line
);
346 printf(" %-34s |", is_caller
? "Callsite": "Alloc Ptr");
347 printf(" Total_alloc/Per | Total_req/Per | Hit | Ping-pong | Frag\n");
348 printf("%.102s\n", graph_dotted_line
);
350 next
= rb_first(root
);
352 machine
= perf_session__find_host_machine(session
);
354 pr_err("__print_result: couldn't find kernel information\n");
357 while (next
&& n_lines
--) {
358 struct alloc_stat
*data
= rb_entry(next
, struct alloc_stat
,
360 struct symbol
*sym
= NULL
;
366 addr
= data
->call_site
;
368 sym
= machine__find_kernel_function(machine
, addr
, &map
, NULL
);
373 snprintf(buf
, sizeof(buf
), "%s+%" PRIx64
"", sym
->name
,
374 addr
- map
->unmap_ip(map
, sym
->start
));
376 snprintf(buf
, sizeof(buf
), "%#" PRIx64
"", addr
);
377 printf(" %-34s |", buf
);
379 printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %8lu | %6.3f%%\n",
380 (unsigned long long)data
->bytes_alloc
,
381 (unsigned long)data
->bytes_alloc
/ data
->hit
,
382 (unsigned long long)data
->bytes_req
,
383 (unsigned long)data
->bytes_req
/ data
->hit
,
384 (unsigned long)data
->hit
,
385 (unsigned long)data
->pingpong
,
386 fragmentation(data
->bytes_req
, data
->bytes_alloc
));
388 next
= rb_next(next
);
392 printf(" ... | ... | ... | ... | ... | ... \n");
394 printf("%.102s\n", graph_dotted_line
);
397 static void print_summary(void)
399 printf("\nSUMMARY\n=======\n");
400 printf("Total bytes requested: %lu\n", total_requested
);
401 printf("Total bytes allocated: %lu\n", total_allocated
);
402 printf("Total bytes wasted on internal fragmentation: %lu\n",
403 total_allocated
- total_requested
);
404 printf("Internal fragmentation: %f%%\n",
405 fragmentation(total_requested
, total_allocated
));
406 printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs
, nr_allocs
);
409 static void print_result(struct perf_session
*session
)
412 __print_result(&root_caller_sorted
, session
, caller_lines
, 1);
414 __print_result(&root_alloc_sorted
, session
, alloc_lines
, 0);
418 struct sort_dimension
{
421 struct list_head list
;
424 static LIST_HEAD(caller_sort
);
425 static LIST_HEAD(alloc_sort
);
427 static void sort_insert(struct rb_root
*root
, struct alloc_stat
*data
,
428 struct list_head
*sort_list
)
430 struct rb_node
**new = &(root
->rb_node
);
431 struct rb_node
*parent
= NULL
;
432 struct sort_dimension
*sort
;
435 struct alloc_stat
*this;
438 this = rb_entry(*new, struct alloc_stat
, node
);
441 list_for_each_entry(sort
, sort_list
, list
) {
442 cmp
= sort
->cmp(data
, this);
448 new = &((*new)->rb_left
);
450 new = &((*new)->rb_right
);
453 rb_link_node(&data
->node
, parent
, new);
454 rb_insert_color(&data
->node
, root
);
457 static void __sort_result(struct rb_root
*root
, struct rb_root
*root_sorted
,
458 struct list_head
*sort_list
)
460 struct rb_node
*node
;
461 struct alloc_stat
*data
;
464 node
= rb_first(root
);
468 rb_erase(node
, root
);
469 data
= rb_entry(node
, struct alloc_stat
, node
);
470 sort_insert(root_sorted
, data
, sort_list
);
474 static void sort_result(void)
476 __sort_result(&root_alloc_stat
, &root_alloc_sorted
, &alloc_sort
);
477 __sort_result(&root_caller_stat
, &root_caller_sorted
, &caller_sort
);
480 static int __cmd_kmem(void)
483 struct perf_session
*session
;
484 const struct perf_evsel_str_handler kmem_tracepoints
[] = {
485 { "kmem:kmalloc", perf_evsel__process_alloc_event
, },
486 { "kmem:kmem_cache_alloc", perf_evsel__process_alloc_event
, },
487 { "kmem:kmalloc_node", perf_evsel__process_alloc_node_event
, },
488 { "kmem:kmem_cache_alloc_node", perf_evsel__process_alloc_node_event
, },
489 { "kmem:kfree", perf_evsel__process_free_event
, },
490 { "kmem:kmem_cache_free", perf_evsel__process_free_event
, },
493 session
= perf_session__new(input_name
, O_RDONLY
, 0, false, &perf_kmem
);
497 if (perf_session__create_kernel_maps(session
) < 0)
500 if (!perf_session__has_traces(session
, "kmem record"))
503 if (perf_session__set_tracepoints_handlers(session
, kmem_tracepoints
)) {
504 pr_err("Initializing perf session tracepoint handlers failed\n");
509 err
= perf_session__process_events(session
, &perf_kmem
);
513 print_result(session
);
515 perf_session__delete(session
);
519 static int ptr_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
523 else if (l
->ptr
> r
->ptr
)
528 static struct sort_dimension ptr_sort_dimension
= {
533 static int callsite_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
535 if (l
->call_site
< r
->call_site
)
537 else if (l
->call_site
> r
->call_site
)
542 static struct sort_dimension callsite_sort_dimension
= {
547 static int hit_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
551 else if (l
->hit
> r
->hit
)
556 static struct sort_dimension hit_sort_dimension
= {
561 static int bytes_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
563 if (l
->bytes_alloc
< r
->bytes_alloc
)
565 else if (l
->bytes_alloc
> r
->bytes_alloc
)
570 static struct sort_dimension bytes_sort_dimension
= {
575 static int frag_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
579 x
= fragmentation(l
->bytes_req
, l
->bytes_alloc
);
580 y
= fragmentation(r
->bytes_req
, r
->bytes_alloc
);
589 static struct sort_dimension frag_sort_dimension
= {
594 static int pingpong_cmp(struct alloc_stat
*l
, struct alloc_stat
*r
)
596 if (l
->pingpong
< r
->pingpong
)
598 else if (l
->pingpong
> r
->pingpong
)
603 static struct sort_dimension pingpong_sort_dimension
= {
608 static struct sort_dimension
*avail_sorts
[] = {
610 &callsite_sort_dimension
,
612 &bytes_sort_dimension
,
613 &frag_sort_dimension
,
614 &pingpong_sort_dimension
,
617 #define NUM_AVAIL_SORTS \
618 (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
620 static int sort_dimension__add(const char *tok
, struct list_head
*list
)
622 struct sort_dimension
*sort
;
625 for (i
= 0; i
< NUM_AVAIL_SORTS
; i
++) {
626 if (!strcmp(avail_sorts
[i
]->name
, tok
)) {
627 sort
= malloc(sizeof(*sort
));
629 pr_err("%s: malloc failed\n", __func__
);
632 memcpy(sort
, avail_sorts
[i
], sizeof(*sort
));
633 list_add_tail(&sort
->list
, list
);
641 static int setup_sorting(struct list_head
*sort_list
, const char *arg
)
644 char *str
= strdup(arg
);
647 pr_err("%s: strdup failed\n", __func__
);
652 tok
= strsep(&str
, ",");
655 if (sort_dimension__add(tok
, sort_list
) < 0) {
656 error("Unknown --sort key: '%s'", tok
);
666 static int parse_sort_opt(const struct option
*opt __maybe_unused
,
667 const char *arg
, int unset __maybe_unused
)
672 if (caller_flag
> alloc_flag
)
673 return setup_sorting(&caller_sort
, arg
);
675 return setup_sorting(&alloc_sort
, arg
);
680 static int parse_caller_opt(const struct option
*opt __maybe_unused
,
681 const char *arg __maybe_unused
,
682 int unset __maybe_unused
)
684 caller_flag
= (alloc_flag
+ 1);
688 static int parse_alloc_opt(const struct option
*opt __maybe_unused
,
689 const char *arg __maybe_unused
,
690 int unset __maybe_unused
)
692 alloc_flag
= (caller_flag
+ 1);
696 static int parse_line_opt(const struct option
*opt __maybe_unused
,
697 const char *arg
, int unset __maybe_unused
)
704 lines
= strtoul(arg
, NULL
, 10);
706 if (caller_flag
> alloc_flag
)
707 caller_lines
= lines
;
714 static int __cmd_record(int argc
, const char **argv
)
716 const char * const record_args
[] = {
717 "record", "-a", "-R", "-f", "-c", "1",
718 "-e", "kmem:kmalloc",
719 "-e", "kmem:kmalloc_node",
721 "-e", "kmem:kmem_cache_alloc",
722 "-e", "kmem:kmem_cache_alloc_node",
723 "-e", "kmem:kmem_cache_free",
725 unsigned int rec_argc
, i
, j
;
726 const char **rec_argv
;
728 rec_argc
= ARRAY_SIZE(record_args
) + argc
- 1;
729 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
731 if (rec_argv
== NULL
)
734 for (i
= 0; i
< ARRAY_SIZE(record_args
); i
++)
735 rec_argv
[i
] = strdup(record_args
[i
]);
737 for (j
= 1; j
< (unsigned int)argc
; j
++, i
++)
738 rec_argv
[i
] = argv
[j
];
740 return cmd_record(i
, rec_argv
, NULL
);
743 int cmd_kmem(int argc
, const char **argv
, const char *prefix __maybe_unused
)
745 const char * const default_sort_order
= "frag,hit,bytes";
746 const struct option kmem_options
[] = {
747 OPT_STRING('i', "input", &input_name
, "file", "input file name"),
748 OPT_CALLBACK_NOOPT(0, "caller", NULL
, NULL
,
749 "show per-callsite statistics", parse_caller_opt
),
750 OPT_CALLBACK_NOOPT(0, "alloc", NULL
, NULL
,
751 "show per-allocation statistics", parse_alloc_opt
),
752 OPT_CALLBACK('s', "sort", NULL
, "key[,key2...]",
753 "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
755 OPT_CALLBACK('l', "line", NULL
, "num", "show n lines", parse_line_opt
),
756 OPT_BOOLEAN(0, "raw-ip", &raw_ip
, "show raw ip instead of symbol"),
759 const char * const kmem_usage
[] = {
760 "perf kmem [<options>] {record|stat}",
763 argc
= parse_options(argc
, argv
, kmem_options
, kmem_usage
, 0);
766 usage_with_options(kmem_usage
, kmem_options
);
770 if (!strncmp(argv
[0], "rec", 3)) {
771 return __cmd_record(argc
, argv
);
772 } else if (!strcmp(argv
[0], "stat")) {
773 if (setup_cpunode_map())
776 if (list_empty(&caller_sort
))
777 setup_sorting(&caller_sort
, default_sort_order
);
778 if (list_empty(&alloc_sort
))
779 setup_sorting(&alloc_sort
, default_sort_order
);
783 usage_with_options(kmem_usage
, kmem_options
);