blob: 547af48deb4f99081221f566f48dc023ab6b0e76 [file] [log] [blame]
Li Zefanba77c9e2009-11-20 15:53:25 +08001#include "builtin.h"
2#include "perf.h"
3
4#include "util/util.h"
5#include "util/cache.h"
6#include "util/symbol.h"
7#include "util/thread.h"
8#include "util/header.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02009#include "util/session.h"
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020010#include "util/tool.h"
Li Zefanba77c9e2009-11-20 15:53:25 +080011
12#include "util/parse-options.h"
13#include "util/trace-event.h"
14
15#include "util/debug.h"
Li Zefanba77c9e2009-11-20 15:53:25 +080016
17#include <linux/rbtree.h>
18
19struct alloc_stat;
20typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);
21
Robert Richterefad1412011-12-07 10:02:54 +010022static const char *input_name;
Li Zefanba77c9e2009-11-20 15:53:25 +080023
Li Zefanba77c9e2009-11-20 15:53:25 +080024static int alloc_flag;
25static int caller_flag;
26
Li Zefanba77c9e2009-11-20 15:53:25 +080027static int alloc_lines = -1;
28static int caller_lines = -1;
29
Li Zefan7707b6b2009-11-24 13:25:48 +080030static bool raw_ip;
31
Li Zefan29b3e152009-11-24 13:26:10 +080032static char default_sort_order[] = "frag,hit,bytes";
33
Li Zefan7d0d3942009-11-24 13:26:31 +080034static int *cpunode_map;
35static int max_cpu_num;
36
Li Zefanba77c9e2009-11-20 15:53:25 +080037struct alloc_stat {
Li Zefan079d3f62009-11-24 13:26:55 +080038 u64 call_site;
39 u64 ptr;
Li Zefanba77c9e2009-11-20 15:53:25 +080040 u64 bytes_req;
41 u64 bytes_alloc;
42 u32 hit;
Li Zefan079d3f62009-11-24 13:26:55 +080043 u32 pingpong;
44
45 short alloc_cpu;
Li Zefanba77c9e2009-11-20 15:53:25 +080046
47 struct rb_node node;
48};
49
50static struct rb_root root_alloc_stat;
51static struct rb_root root_alloc_sorted;
52static struct rb_root root_caller_stat;
53static struct rb_root root_caller_sorted;
54
55static unsigned long total_requested, total_allocated;
Li Zefan7d0d3942009-11-24 13:26:31 +080056static unsigned long nr_allocs, nr_cross_allocs;
Li Zefanba77c9e2009-11-20 15:53:25 +080057
Li Zefan7d0d3942009-11-24 13:26:31 +080058#define PATH_SYS_NODE "/sys/devices/system/node"
59
60static void init_cpunode_map(void)
61{
62 FILE *fp;
63 int i;
64
65 fp = fopen("/sys/devices/system/cpu/kernel_max", "r");
66 if (!fp) {
67 max_cpu_num = 4096;
68 return;
69 }
70
71 if (fscanf(fp, "%d", &max_cpu_num) < 1)
72 die("Failed to read 'kernel_max' from sysfs");
73 max_cpu_num++;
74
75 cpunode_map = calloc(max_cpu_num, sizeof(int));
76 if (!cpunode_map)
77 die("calloc");
78 for (i = 0; i < max_cpu_num; i++)
79 cpunode_map[i] = -1;
80 fclose(fp);
81}
82
83static void setup_cpunode_map(void)
84{
85 struct dirent *dent1, *dent2;
86 DIR *dir1, *dir2;
87 unsigned int cpu, mem;
88 char buf[PATH_MAX];
89
90 init_cpunode_map();
91
92 dir1 = opendir(PATH_SYS_NODE);
93 if (!dir1)
94 return;
95
Ulrich Drepper659d8cf2009-12-19 16:40:28 -050096 while ((dent1 = readdir(dir1)) != NULL) {
97 if (dent1->d_type != DT_DIR ||
98 sscanf(dent1->d_name, "node%u", &mem) < 1)
Li Zefan7d0d3942009-11-24 13:26:31 +080099 continue;
100
101 snprintf(buf, PATH_MAX, "%s/%s", PATH_SYS_NODE, dent1->d_name);
102 dir2 = opendir(buf);
103 if (!dir2)
104 continue;
Ulrich Drepper659d8cf2009-12-19 16:40:28 -0500105 while ((dent2 = readdir(dir2)) != NULL) {
106 if (dent2->d_type != DT_LNK ||
107 sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
Li Zefan7d0d3942009-11-24 13:26:31 +0800108 continue;
109 cpunode_map[cpu] = mem;
110 }
Namhyung Kim8442da12012-01-08 02:25:28 +0900111 closedir(dir2);
Li Zefan7d0d3942009-11-24 13:26:31 +0800112 }
Namhyung Kim8442da12012-01-08 02:25:28 +0900113 closedir(dir1);
Li Zefan7d0d3942009-11-24 13:26:31 +0800114}
115
Li Zefan079d3f62009-11-24 13:26:55 +0800116static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
117 int bytes_req, int bytes_alloc, int cpu)
Li Zefanba77c9e2009-11-20 15:53:25 +0800118{
119 struct rb_node **node = &root_alloc_stat.rb_node;
120 struct rb_node *parent = NULL;
121 struct alloc_stat *data = NULL;
122
Li Zefanba77c9e2009-11-20 15:53:25 +0800123 while (*node) {
124 parent = *node;
125 data = rb_entry(*node, struct alloc_stat, node);
126
127 if (ptr > data->ptr)
128 node = &(*node)->rb_right;
129 else if (ptr < data->ptr)
130 node = &(*node)->rb_left;
131 else
132 break;
133 }
134
135 if (data && data->ptr == ptr) {
136 data->hit++;
137 data->bytes_req += bytes_req;
Wenji Huang4efb5292009-12-21 17:52:55 +0800138 data->bytes_alloc += bytes_alloc;
Li Zefanba77c9e2009-11-20 15:53:25 +0800139 } else {
140 data = malloc(sizeof(*data));
Li Zefan079d3f62009-11-24 13:26:55 +0800141 if (!data)
142 die("malloc");
Li Zefanba77c9e2009-11-20 15:53:25 +0800143 data->ptr = ptr;
Li Zefan079d3f62009-11-24 13:26:55 +0800144 data->pingpong = 0;
Li Zefanba77c9e2009-11-20 15:53:25 +0800145 data->hit = 1;
146 data->bytes_req = bytes_req;
147 data->bytes_alloc = bytes_alloc;
148
149 rb_link_node(&data->node, parent, node);
150 rb_insert_color(&data->node, &root_alloc_stat);
151 }
Li Zefan079d3f62009-11-24 13:26:55 +0800152 data->call_site = call_site;
153 data->alloc_cpu = cpu;
Li Zefanba77c9e2009-11-20 15:53:25 +0800154}
155
156static void insert_caller_stat(unsigned long call_site,
157 int bytes_req, int bytes_alloc)
158{
159 struct rb_node **node = &root_caller_stat.rb_node;
160 struct rb_node *parent = NULL;
161 struct alloc_stat *data = NULL;
162
Li Zefanba77c9e2009-11-20 15:53:25 +0800163 while (*node) {
164 parent = *node;
165 data = rb_entry(*node, struct alloc_stat, node);
166
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;
171 else
172 break;
173 }
174
175 if (data && data->call_site == call_site) {
176 data->hit++;
177 data->bytes_req += bytes_req;
Wenji Huang4efb5292009-12-21 17:52:55 +0800178 data->bytes_alloc += bytes_alloc;
Li Zefanba77c9e2009-11-20 15:53:25 +0800179 } else {
180 data = malloc(sizeof(*data));
Li Zefan079d3f62009-11-24 13:26:55 +0800181 if (!data)
182 die("malloc");
Li Zefanba77c9e2009-11-20 15:53:25 +0800183 data->call_site = call_site;
Li Zefan079d3f62009-11-24 13:26:55 +0800184 data->pingpong = 0;
Li Zefanba77c9e2009-11-20 15:53:25 +0800185 data->hit = 1;
186 data->bytes_req = bytes_req;
187 data->bytes_alloc = bytes_alloc;
188
189 rb_link_node(&data->node, parent, node);
190 rb_insert_color(&data->node, &root_caller_stat);
191 }
192}
193
Xiao Guangrongf48f6692009-12-07 13:04:04 +0800194static void process_alloc_event(void *data,
Steven Rostedtaaf045f2012-04-06 00:47:56 +0200195 struct event_format *event,
Li Zefan7d0d3942009-11-24 13:26:31 +0800196 int cpu,
Li Zefanba77c9e2009-11-20 15:53:25 +0800197 u64 timestamp __used,
198 struct thread *thread __used,
Li Zefan7d0d3942009-11-24 13:26:31 +0800199 int node)
Li Zefanba77c9e2009-11-20 15:53:25 +0800200{
201 unsigned long call_site;
202 unsigned long ptr;
203 int bytes_req;
204 int bytes_alloc;
Li Zefan7d0d3942009-11-24 13:26:31 +0800205 int node1, node2;
Li Zefanba77c9e2009-11-20 15:53:25 +0800206
Xiao Guangrongf48f6692009-12-07 13:04:04 +0800207 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);
Li Zefanba77c9e2009-11-20 15:53:25 +0800211
Li Zefan079d3f62009-11-24 13:26:55 +0800212 insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
Li Zefanba77c9e2009-11-20 15:53:25 +0800213 insert_caller_stat(call_site, bytes_req, bytes_alloc);
214
215 total_requested += bytes_req;
216 total_allocated += bytes_alloc;
Li Zefan7d0d3942009-11-24 13:26:31 +0800217
218 if (node) {
219 node1 = cpunode_map[cpu];
Xiao Guangrongf48f6692009-12-07 13:04:04 +0800220 node2 = raw_field_value(event, "node", data);
Li Zefan7d0d3942009-11-24 13:26:31 +0800221 if (node1 != node2)
222 nr_cross_allocs++;
223 }
224 nr_allocs++;
Li Zefanba77c9e2009-11-20 15:53:25 +0800225}
226
Li Zefan079d3f62009-11-24 13:26:55 +0800227static int ptr_cmp(struct alloc_stat *, struct alloc_stat *);
228static int callsite_cmp(struct alloc_stat *, struct alloc_stat *);
229
230static struct alloc_stat *search_alloc_stat(unsigned long ptr,
231 unsigned long call_site,
232 struct rb_root *root,
233 sort_fn_t sort_fn)
234{
235 struct rb_node *node = root->rb_node;
236 struct alloc_stat key = { .ptr = ptr, .call_site = call_site };
237
238 while (node) {
239 struct alloc_stat *data;
240 int cmp;
241
242 data = rb_entry(node, struct alloc_stat, node);
243
244 cmp = sort_fn(&key, data);
245 if (cmp < 0)
246 node = node->rb_left;
247 else if (cmp > 0)
248 node = node->rb_right;
249 else
250 return data;
251 }
252 return NULL;
253}
254
Xiao Guangrongf48f6692009-12-07 13:04:04 +0800255static void process_free_event(void *data,
Steven Rostedtaaf045f2012-04-06 00:47:56 +0200256 struct event_format *event,
Li Zefan079d3f62009-11-24 13:26:55 +0800257 int cpu,
Li Zefanba77c9e2009-11-20 15:53:25 +0800258 u64 timestamp __used,
259 struct thread *thread __used)
260{
Li Zefan079d3f62009-11-24 13:26:55 +0800261 unsigned long ptr;
262 struct alloc_stat *s_alloc, *s_caller;
263
Xiao Guangrongf48f6692009-12-07 13:04:04 +0800264 ptr = raw_field_value(event, "ptr", data);
Li Zefan079d3f62009-11-24 13:26:55 +0800265
266 s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp);
267 if (!s_alloc)
268 return;
269
270 if (cpu != s_alloc->alloc_cpu) {
271 s_alloc->pingpong++;
272
273 s_caller = search_alloc_stat(0, s_alloc->call_site,
274 &root_caller_stat, callsite_cmp);
275 assert(s_caller);
276 s_caller->pingpong++;
277 }
278 s_alloc->alloc_cpu = -1;
Li Zefanba77c9e2009-11-20 15:53:25 +0800279}
280
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200281static void process_raw_event(union perf_event *raw_event __used, void *data,
282 int cpu, u64 timestamp, struct thread *thread)
Li Zefanba77c9e2009-11-20 15:53:25 +0800283{
Steven Rostedtaaf045f2012-04-06 00:47:56 +0200284 struct event_format *event;
Li Zefanba77c9e2009-11-20 15:53:25 +0800285 int type;
286
Xiao Guangrongf48f6692009-12-07 13:04:04 +0800287 type = trace_parse_common_type(data);
Li Zefanba77c9e2009-11-20 15:53:25 +0800288 event = trace_find_event(type);
289
290 if (!strcmp(event->name, "kmalloc") ||
291 !strcmp(event->name, "kmem_cache_alloc")) {
Xiao Guangrongf48f6692009-12-07 13:04:04 +0800292 process_alloc_event(data, event, cpu, timestamp, thread, 0);
Li Zefanba77c9e2009-11-20 15:53:25 +0800293 return;
294 }
295
296 if (!strcmp(event->name, "kmalloc_node") ||
297 !strcmp(event->name, "kmem_cache_alloc_node")) {
Xiao Guangrongf48f6692009-12-07 13:04:04 +0800298 process_alloc_event(data, event, cpu, timestamp, thread, 1);
Li Zefanba77c9e2009-11-20 15:53:25 +0800299 return;
300 }
301
302 if (!strcmp(event->name, "kfree") ||
303 !strcmp(event->name, "kmem_cache_free")) {
Xiao Guangrongf48f6692009-12-07 13:04:04 +0800304 process_free_event(data, event, cpu, timestamp, thread);
Li Zefanba77c9e2009-11-20 15:53:25 +0800305 return;
306 }
307}
308
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200309static int process_sample_event(struct perf_tool *tool __used,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200310 union perf_event *event,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200311 struct perf_sample *sample,
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300312 struct perf_evsel *evsel __used,
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200313 struct machine *machine)
Li Zefanba77c9e2009-11-20 15:53:25 +0800314{
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200315 struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
Li Zefanba77c9e2009-11-20 15:53:25 +0800316
Li Zefanba77c9e2009-11-20 15:53:25 +0800317 if (thread == NULL) {
318 pr_debug("problem processing %d event, skipping it.\n",
319 event->header.type);
320 return -1;
321 }
322
323 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
324
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200325 process_raw_event(event, sample->raw_data, sample->cpu,
326 sample->time, thread);
Li Zefanba77c9e2009-11-20 15:53:25 +0800327
328 return 0;
329}
330
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200331static struct perf_tool perf_kmem = {
Frederic Weisbecker587570d2010-04-24 00:34:53 +0200332 .sample = process_sample_event,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200333 .comm = perf_event__process_comm,
Frederic Weisbecker587570d2010-04-24 00:34:53 +0200334 .ordered_samples = true,
Li Zefanba77c9e2009-11-20 15:53:25 +0800335};
336
Li Zefanba77c9e2009-11-20 15:53:25 +0800337static double fragmentation(unsigned long n_req, unsigned long n_alloc)
338{
339 if (n_alloc == 0)
340 return 0.0;
341 else
342 return 100.0 - (100.0 * n_req / n_alloc);
343}
344
Arnaldo Carvalho de Melo4aa65632009-12-13 19:50:29 -0200345static void __print_result(struct rb_root *root, struct perf_session *session,
346 int n_lines, int is_caller)
Li Zefanba77c9e2009-11-20 15:53:25 +0800347{
348 struct rb_node *next;
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300349 struct machine *machine;
Li Zefanba77c9e2009-11-20 15:53:25 +0800350
Li Zefan079d3f62009-11-24 13:26:55 +0800351 printf("%.102s\n", graph_dotted_line);
352 printf(" %-34s |", is_caller ? "Callsite": "Alloc Ptr");
Pekka Enberg47103272010-01-19 19:23:23 +0200353 printf(" Total_alloc/Per | Total_req/Per | Hit | Ping-pong | Frag\n");
Li Zefan079d3f62009-11-24 13:26:55 +0800354 printf("%.102s\n", graph_dotted_line);
Li Zefanba77c9e2009-11-20 15:53:25 +0800355
356 next = rb_first(root);
357
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300358 machine = perf_session__find_host_machine(session);
359 if (!machine) {
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800360 pr_err("__print_result: couldn't find kernel information\n");
361 return;
362 }
Li Zefanba77c9e2009-11-20 15:53:25 +0800363 while (next && n_lines--) {
Arnaldo Carvalho de Melo1b145ae2009-11-23 17:51:09 -0200364 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
365 node);
366 struct symbol *sym = NULL;
Arnaldo Carvalho de Melo71cf8b82010-04-01 21:24:38 -0300367 struct map *map;
Li Zefan079d3f62009-11-24 13:26:55 +0800368 char buf[BUFSIZ];
Arnaldo Carvalho de Melo1b145ae2009-11-23 17:51:09 -0200369 u64 addr;
Li Zefanba77c9e2009-11-20 15:53:25 +0800370
Arnaldo Carvalho de Melo1b145ae2009-11-23 17:51:09 -0200371 if (is_caller) {
372 addr = data->call_site;
Li Zefan7707b6b2009-11-24 13:25:48 +0800373 if (!raw_ip)
Arnaldo Carvalho de Melo5c0541d2010-04-29 15:25:23 -0300374 sym = machine__find_kernel_function(machine, addr, &map, NULL);
Arnaldo Carvalho de Melo1b145ae2009-11-23 17:51:09 -0200375 } else
376 addr = data->ptr;
Li Zefanba77c9e2009-11-20 15:53:25 +0800377
Arnaldo Carvalho de Melo1b145ae2009-11-23 17:51:09 -0200378 if (sym != NULL)
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200379 snprintf(buf, sizeof(buf), "%s+%" PRIx64 "", sym->name,
Arnaldo Carvalho de Melo71cf8b82010-04-01 21:24:38 -0300380 addr - map->unmap_ip(map, sym->start));
Arnaldo Carvalho de Melo1b145ae2009-11-23 17:51:09 -0200381 else
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200382 snprintf(buf, sizeof(buf), "%#" PRIx64 "", addr);
Li Zefan079d3f62009-11-24 13:26:55 +0800383 printf(" %-34s |", buf);
Arnaldo Carvalho de Melo1b145ae2009-11-23 17:51:09 -0200384
Pekka Enberg47103272010-01-19 19:23:23 +0200385 printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %8lu | %6.3f%%\n",
Li Zefan079d3f62009-11-24 13:26:55 +0800386 (unsigned long long)data->bytes_alloc,
Li Zefanba77c9e2009-11-20 15:53:25 +0800387 (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,
Li Zefan079d3f62009-11-24 13:26:55 +0800391 (unsigned long)data->pingpong,
Li Zefanba77c9e2009-11-20 15:53:25 +0800392 fragmentation(data->bytes_req, data->bytes_alloc));
393
394 next = rb_next(next);
395 }
396
397 if (n_lines == -1)
Li Zefan079d3f62009-11-24 13:26:55 +0800398 printf(" ... | ... | ... | ... | ... | ... \n");
Li Zefanba77c9e2009-11-20 15:53:25 +0800399
Li Zefan079d3f62009-11-24 13:26:55 +0800400 printf("%.102s\n", graph_dotted_line);
Li Zefanba77c9e2009-11-20 15:53:25 +0800401}
402
403static void print_summary(void)
404{
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));
Li Zefan7d0d3942009-11-24 13:26:31 +0800412 printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
Li Zefanba77c9e2009-11-20 15:53:25 +0800413}
414
Arnaldo Carvalho de Melo4aa65632009-12-13 19:50:29 -0200415static void print_result(struct perf_session *session)
Li Zefanba77c9e2009-11-20 15:53:25 +0800416{
417 if (caller_flag)
Arnaldo Carvalho de Melo4aa65632009-12-13 19:50:29 -0200418 __print_result(&root_caller_sorted, session, caller_lines, 1);
Li Zefanba77c9e2009-11-20 15:53:25 +0800419 if (alloc_flag)
Arnaldo Carvalho de Melo4aa65632009-12-13 19:50:29 -0200420 __print_result(&root_alloc_sorted, session, alloc_lines, 0);
Li Zefanba77c9e2009-11-20 15:53:25 +0800421 print_summary();
422}
423
Li Zefan29b3e152009-11-24 13:26:10 +0800424struct sort_dimension {
425 const char name[20];
426 sort_fn_t cmp;
427 struct list_head list;
428};
429
430static LIST_HEAD(caller_sort);
431static LIST_HEAD(alloc_sort);
432
Li Zefanba77c9e2009-11-20 15:53:25 +0800433static void sort_insert(struct rb_root *root, struct alloc_stat *data,
Li Zefan29b3e152009-11-24 13:26:10 +0800434 struct list_head *sort_list)
Li Zefanba77c9e2009-11-20 15:53:25 +0800435{
436 struct rb_node **new = &(root->rb_node);
437 struct rb_node *parent = NULL;
Li Zefan29b3e152009-11-24 13:26:10 +0800438 struct sort_dimension *sort;
Li Zefanba77c9e2009-11-20 15:53:25 +0800439
440 while (*new) {
441 struct alloc_stat *this;
Li Zefan29b3e152009-11-24 13:26:10 +0800442 int cmp = 0;
Li Zefanba77c9e2009-11-20 15:53:25 +0800443
444 this = rb_entry(*new, struct alloc_stat, node);
445 parent = *new;
446
Li Zefan29b3e152009-11-24 13:26:10 +0800447 list_for_each_entry(sort, sort_list, list) {
448 cmp = sort->cmp(data, this);
449 if (cmp)
450 break;
451 }
Li Zefanba77c9e2009-11-20 15:53:25 +0800452
453 if (cmp > 0)
454 new = &((*new)->rb_left);
455 else
456 new = &((*new)->rb_right);
457 }
458
459 rb_link_node(&data->node, parent, new);
460 rb_insert_color(&data->node, root);
461}
462
463static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
Li Zefan29b3e152009-11-24 13:26:10 +0800464 struct list_head *sort_list)
Li Zefanba77c9e2009-11-20 15:53:25 +0800465{
466 struct rb_node *node;
467 struct alloc_stat *data;
468
469 for (;;) {
470 node = rb_first(root);
471 if (!node)
472 break;
473
474 rb_erase(node, root);
475 data = rb_entry(node, struct alloc_stat, node);
Li Zefan29b3e152009-11-24 13:26:10 +0800476 sort_insert(root_sorted, data, sort_list);
Li Zefanba77c9e2009-11-20 15:53:25 +0800477 }
478}
479
480static void sort_result(void)
481{
Li Zefan29b3e152009-11-24 13:26:10 +0800482 __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
483 __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
Li Zefanba77c9e2009-11-20 15:53:25 +0800484}
485
486static int __cmd_kmem(void)
487{
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -0200488 int err = -EINVAL;
Ian Munsie21ef97f2010-12-10 14:09:16 +1100489 struct perf_session *session = perf_session__new(input_name, O_RDONLY,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200490 0, false, &perf_kmem);
Arnaldo Carvalho de Melo4aa65632009-12-13 19:50:29 -0200491 if (session == NULL)
492 return -ENOMEM;
Li Zefanba77c9e2009-11-20 15:53:25 +0800493
Arnaldo Carvalho de Meloe727ca72010-04-01 19:12:13 -0300494 if (perf_session__create_kernel_maps(session) < 0)
495 goto out_delete;
496
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -0200497 if (!perf_session__has_traces(session, "kmem record"))
498 goto out_delete;
499
Arnaldo Carvalho de Melo4aa65632009-12-13 19:50:29 -0200500 setup_pager();
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200501 err = perf_session__process_events(session, &perf_kmem);
Arnaldo Carvalho de Melo4aa65632009-12-13 19:50:29 -0200502 if (err != 0)
503 goto out_delete;
504 sort_result();
505 print_result(session);
506out_delete:
507 perf_session__delete(session);
508 return err;
Li Zefanba77c9e2009-11-20 15:53:25 +0800509}
510
511static const char * const kmem_usage[] = {
Li Zefan90b86a92009-12-10 15:21:57 +0800512 "perf kmem [<options>] {record|stat}",
Li Zefanba77c9e2009-11-20 15:53:25 +0800513 NULL
514};
515
Li Zefanba77c9e2009-11-20 15:53:25 +0800516static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r)
517{
518 if (l->ptr < r->ptr)
519 return -1;
520 else if (l->ptr > r->ptr)
521 return 1;
522 return 0;
523}
524
Li Zefan29b3e152009-11-24 13:26:10 +0800525static struct sort_dimension ptr_sort_dimension = {
526 .name = "ptr",
527 .cmp = ptr_cmp,
528};
529
Li Zefanba77c9e2009-11-20 15:53:25 +0800530static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r)
531{
532 if (l->call_site < r->call_site)
533 return -1;
534 else if (l->call_site > r->call_site)
535 return 1;
536 return 0;
537}
538
Li Zefan29b3e152009-11-24 13:26:10 +0800539static struct sort_dimension callsite_sort_dimension = {
540 .name = "callsite",
541 .cmp = callsite_cmp,
542};
543
Pekka Enbergf3ced7c2009-11-22 11:58:00 +0200544static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r)
545{
546 if (l->hit < r->hit)
547 return -1;
548 else if (l->hit > r->hit)
549 return 1;
550 return 0;
551}
552
Li Zefan29b3e152009-11-24 13:26:10 +0800553static struct sort_dimension hit_sort_dimension = {
554 .name = "hit",
555 .cmp = hit_cmp,
556};
557
Li Zefanba77c9e2009-11-20 15:53:25 +0800558static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r)
559{
560 if (l->bytes_alloc < r->bytes_alloc)
561 return -1;
562 else if (l->bytes_alloc > r->bytes_alloc)
563 return 1;
564 return 0;
565}
566
Li Zefan29b3e152009-11-24 13:26:10 +0800567static struct sort_dimension bytes_sort_dimension = {
568 .name = "bytes",
569 .cmp = bytes_cmp,
570};
571
Pekka Enbergf3ced7c2009-11-22 11:58:00 +0200572static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r)
573{
574 double x, y;
575
576 x = fragmentation(l->bytes_req, l->bytes_alloc);
577 y = fragmentation(r->bytes_req, r->bytes_alloc);
578
579 if (x < y)
580 return -1;
581 else if (x > y)
582 return 1;
583 return 0;
584}
585
Li Zefan29b3e152009-11-24 13:26:10 +0800586static struct sort_dimension frag_sort_dimension = {
587 .name = "frag",
588 .cmp = frag_cmp,
589};
590
Li Zefan079d3f62009-11-24 13:26:55 +0800591static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r)
592{
593 if (l->pingpong < r->pingpong)
594 return -1;
595 else if (l->pingpong > r->pingpong)
596 return 1;
597 return 0;
598}
599
600static struct sort_dimension pingpong_sort_dimension = {
601 .name = "pingpong",
602 .cmp = pingpong_cmp,
603};
604
Li Zefan29b3e152009-11-24 13:26:10 +0800605static struct sort_dimension *avail_sorts[] = {
606 &ptr_sort_dimension,
607 &callsite_sort_dimension,
608 &hit_sort_dimension,
609 &bytes_sort_dimension,
610 &frag_sort_dimension,
Li Zefan079d3f62009-11-24 13:26:55 +0800611 &pingpong_sort_dimension,
Li Zefan29b3e152009-11-24 13:26:10 +0800612};
613
614#define NUM_AVAIL_SORTS \
615 (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
616
617static int sort_dimension__add(const char *tok, struct list_head *list)
618{
619 struct sort_dimension *sort;
620 int i;
621
622 for (i = 0; i < NUM_AVAIL_SORTS; i++) {
623 if (!strcmp(avail_sorts[i]->name, tok)) {
624 sort = malloc(sizeof(*sort));
625 if (!sort)
626 die("malloc");
627 memcpy(sort, avail_sorts[i], sizeof(*sort));
628 list_add_tail(&sort->list, list);
629 return 0;
630 }
631 }
632
633 return -1;
634}
635
636static int setup_sorting(struct list_head *sort_list, const char *arg)
637{
638 char *tok;
639 char *str = strdup(arg);
640
641 if (!str)
642 die("strdup");
643
644 while (true) {
645 tok = strsep(&str, ",");
646 if (!tok)
647 break;
648 if (sort_dimension__add(tok, sort_list) < 0) {
649 error("Unknown --sort key: '%s'", tok);
Namhyung Kim1b228592012-01-08 02:25:29 +0900650 free(str);
Li Zefan29b3e152009-11-24 13:26:10 +0800651 return -1;
652 }
653 }
654
655 free(str);
656 return 0;
657}
658
Li Zefanba77c9e2009-11-20 15:53:25 +0800659static int parse_sort_opt(const struct option *opt __used,
660 const char *arg, int unset __used)
661{
Li Zefanba77c9e2009-11-20 15:53:25 +0800662 if (!arg)
663 return -1;
664
Li Zefanba77c9e2009-11-20 15:53:25 +0800665 if (caller_flag > alloc_flag)
Li Zefan29b3e152009-11-24 13:26:10 +0800666 return setup_sorting(&caller_sort, arg);
Li Zefanba77c9e2009-11-20 15:53:25 +0800667 else
Li Zefan29b3e152009-11-24 13:26:10 +0800668 return setup_sorting(&alloc_sort, arg);
Li Zefanba77c9e2009-11-20 15:53:25 +0800669
670 return 0;
671}
672
Li Zefan90b86a92009-12-10 15:21:57 +0800673static int parse_caller_opt(const struct option *opt __used,
Ingo Molnar79312412009-12-10 08:43:34 +0100674 const char *arg __used, int unset __used)
Li Zefanba77c9e2009-11-20 15:53:25 +0800675{
Li Zefan90b86a92009-12-10 15:21:57 +0800676 caller_flag = (alloc_flag + 1);
677 return 0;
678}
Li Zefanba77c9e2009-11-20 15:53:25 +0800679
Li Zefan90b86a92009-12-10 15:21:57 +0800680static int parse_alloc_opt(const struct option *opt __used,
Ingo Molnar79312412009-12-10 08:43:34 +0100681 const char *arg __used, int unset __used)
Li Zefan90b86a92009-12-10 15:21:57 +0800682{
683 alloc_flag = (caller_flag + 1);
Li Zefanba77c9e2009-11-20 15:53:25 +0800684 return 0;
685}
686
687static int parse_line_opt(const struct option *opt __used,
688 const char *arg, int unset __used)
689{
690 int lines;
691
692 if (!arg)
693 return -1;
694
695 lines = strtoul(arg, NULL, 10);
696
697 if (caller_flag > alloc_flag)
698 caller_lines = lines;
699 else
700 alloc_lines = lines;
701
702 return 0;
703}
704
705static const struct option kmem_options[] = {
706 OPT_STRING('i', "input", &input_name, "file",
707 "input file name"),
Li Zefan90b86a92009-12-10 15:21:57 +0800708 OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
709 "show per-callsite statistics",
710 parse_caller_opt),
711 OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
712 "show per-allocation statistics",
713 parse_alloc_opt),
Li Zefan29b3e152009-11-24 13:26:10 +0800714 OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
Li Zefan079d3f62009-11-24 13:26:55 +0800715 "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
Li Zefanba77c9e2009-11-20 15:53:25 +0800716 parse_sort_opt),
717 OPT_CALLBACK('l', "line", NULL, "num",
Li Zefan90b86a92009-12-10 15:21:57 +0800718 "show n lines",
Li Zefanba77c9e2009-11-20 15:53:25 +0800719 parse_line_opt),
Li Zefan7707b6b2009-11-24 13:25:48 +0800720 OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
Li Zefanba77c9e2009-11-20 15:53:25 +0800721 OPT_END()
722};
723
724static const char *record_args[] = {
725 "record",
726 "-a",
727 "-R",
Li Zefanba77c9e2009-11-20 15:53:25 +0800728 "-f",
729 "-c", "1",
730 "-e", "kmem:kmalloc",
731 "-e", "kmem:kmalloc_node",
732 "-e", "kmem:kfree",
733 "-e", "kmem:kmem_cache_alloc",
734 "-e", "kmem:kmem_cache_alloc_node",
735 "-e", "kmem:kmem_cache_free",
736};
737
738static int __cmd_record(int argc, const char **argv)
739{
740 unsigned int rec_argc, i, j;
741 const char **rec_argv;
742
743 rec_argc = ARRAY_SIZE(record_args) + argc - 1;
744 rec_argv = calloc(rec_argc + 1, sizeof(char *));
745
Chris Samuelce47dc52010-11-13 13:35:06 +1100746 if (rec_argv == NULL)
747 return -ENOMEM;
748
Li Zefanba77c9e2009-11-20 15:53:25 +0800749 for (i = 0; i < ARRAY_SIZE(record_args); i++)
750 rec_argv[i] = strdup(record_args[i]);
751
752 for (j = 1; j < (unsigned int)argc; j++, i++)
753 rec_argv[i] = argv[j];
754
755 return cmd_record(i, rec_argv, NULL);
756}
757
758int cmd_kmem(int argc, const char **argv, const char *prefix __used)
759{
Li Zefanba77c9e2009-11-20 15:53:25 +0800760 argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
761
Li Zefan90b86a92009-12-10 15:21:57 +0800762 if (!argc)
Li Zefanba77c9e2009-11-20 15:53:25 +0800763 usage_with_options(kmem_usage, kmem_options);
764
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -0200765 symbol__init();
766
Li Zefan90b86a92009-12-10 15:21:57 +0800767 if (!strncmp(argv[0], "rec", 3)) {
768 return __cmd_record(argc, argv);
769 } else if (!strcmp(argv[0], "stat")) {
770 setup_cpunode_map();
Li Zefanba77c9e2009-11-20 15:53:25 +0800771
Li Zefan90b86a92009-12-10 15:21:57 +0800772 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);
Li Zefan7d0d3942009-11-24 13:26:31 +0800776
Li Zefan90b86a92009-12-10 15:21:57 +0800777 return __cmd_kmem();
Pekka Enbergb00eca82010-01-19 19:26:11 +0200778 } else
779 usage_with_options(kmem_usage, kmem_options);
Li Zefan90b86a92009-12-10 15:21:57 +0800780
781 return 0;
Li Zefanba77c9e2009-11-20 15:53:25 +0800782}
783