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
);