Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 1 | #include "builtin.h" |
| 2 | #include "perf.h" |
| 3 | |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 4 | #include "util/evlist.h" |
Arnaldo Carvalho de Melo | fcf65bf | 2012-08-07 09:58:03 -0300 | [diff] [blame] | 5 | #include "util/evsel.h" |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 6 | #include "util/util.h" |
| 7 | #include "util/cache.h" |
| 8 | #include "util/symbol.h" |
| 9 | #include "util/thread.h" |
| 10 | #include "util/header.h" |
Arnaldo Carvalho de Melo | 94c744b | 2009-12-11 21:24:02 -0200 | [diff] [blame] | 11 | #include "util/session.h" |
Arnaldo Carvalho de Melo | 45694aa | 2011-11-28 08:30:20 -0200 | [diff] [blame] | 12 | #include "util/tool.h" |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 13 | |
| 14 | #include "util/parse-options.h" |
| 15 | #include "util/trace-event.h" |
Jiri Olsa | f5fc141 | 2013-10-15 16:27:32 +0200 | [diff] [blame] | 16 | #include "util/data.h" |
Don Zickus | 4b62795 | 2014-04-07 14:55:23 -0400 | [diff] [blame] | 17 | #include "util/cpumap.h" |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 18 | |
| 19 | #include "util/debug.h" |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 20 | |
| 21 | #include <linux/rbtree.h> |
Arnaldo Carvalho de Melo | 8d9233f | 2013-01-24 22:24:57 -0300 | [diff] [blame] | 22 | #include <linux/string.h> |
Namhyung Kim | 77cfe38 | 2015-03-23 15:30:40 +0900 | [diff] [blame] | 23 | #include <locale.h> |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 24 | |
| 25 | struct alloc_stat; |
| 26 | typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *); |
| 27 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 28 | static int alloc_flag; |
| 29 | static int caller_flag; |
| 30 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 31 | static int alloc_lines = -1; |
| 32 | static int caller_lines = -1; |
| 33 | |
Li Zefan | 7707b6b | 2009-11-24 13:25:48 +0800 | [diff] [blame] | 34 | static bool raw_ip; |
| 35 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 36 | struct alloc_stat { |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 37 | u64 call_site; |
| 38 | u64 ptr; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 39 | u64 bytes_req; |
| 40 | u64 bytes_alloc; |
| 41 | u32 hit; |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 42 | u32 pingpong; |
| 43 | |
| 44 | short alloc_cpu; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 45 | |
| 46 | struct rb_node node; |
| 47 | }; |
| 48 | |
| 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; |
| 53 | |
| 54 | static unsigned long total_requested, total_allocated; |
Li Zefan | 7d0d394 | 2009-11-24 13:26:31 +0800 | [diff] [blame] | 55 | static unsigned long nr_allocs, nr_cross_allocs; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 56 | |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 57 | static int insert_alloc_stat(unsigned long call_site, unsigned long ptr, |
| 58 | int bytes_req, int bytes_alloc, int cpu) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 59 | { |
| 60 | struct rb_node **node = &root_alloc_stat.rb_node; |
| 61 | struct rb_node *parent = NULL; |
| 62 | struct alloc_stat *data = NULL; |
| 63 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 64 | while (*node) { |
| 65 | parent = *node; |
| 66 | data = rb_entry(*node, struct alloc_stat, node); |
| 67 | |
| 68 | if (ptr > data->ptr) |
| 69 | node = &(*node)->rb_right; |
| 70 | else if (ptr < data->ptr) |
| 71 | node = &(*node)->rb_left; |
| 72 | else |
| 73 | break; |
| 74 | } |
| 75 | |
| 76 | if (data && data->ptr == ptr) { |
| 77 | data->hit++; |
| 78 | data->bytes_req += bytes_req; |
Wenji Huang | 4efb529 | 2009-12-21 17:52:55 +0800 | [diff] [blame] | 79 | data->bytes_alloc += bytes_alloc; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 80 | } else { |
| 81 | data = malloc(sizeof(*data)); |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 82 | if (!data) { |
| 83 | pr_err("%s: malloc failed\n", __func__); |
| 84 | return -1; |
| 85 | } |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 86 | data->ptr = ptr; |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 87 | data->pingpong = 0; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 88 | data->hit = 1; |
| 89 | data->bytes_req = bytes_req; |
| 90 | data->bytes_alloc = bytes_alloc; |
| 91 | |
| 92 | rb_link_node(&data->node, parent, node); |
| 93 | rb_insert_color(&data->node, &root_alloc_stat); |
| 94 | } |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 95 | data->call_site = call_site; |
| 96 | data->alloc_cpu = cpu; |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 97 | return 0; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 98 | } |
| 99 | |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 100 | static int insert_caller_stat(unsigned long call_site, |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 101 | int bytes_req, int bytes_alloc) |
| 102 | { |
| 103 | struct rb_node **node = &root_caller_stat.rb_node; |
| 104 | struct rb_node *parent = NULL; |
| 105 | struct alloc_stat *data = NULL; |
| 106 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 107 | while (*node) { |
| 108 | parent = *node; |
| 109 | data = rb_entry(*node, struct alloc_stat, node); |
| 110 | |
| 111 | if (call_site > data->call_site) |
| 112 | node = &(*node)->rb_right; |
| 113 | else if (call_site < data->call_site) |
| 114 | node = &(*node)->rb_left; |
| 115 | else |
| 116 | break; |
| 117 | } |
| 118 | |
| 119 | if (data && data->call_site == call_site) { |
| 120 | data->hit++; |
| 121 | data->bytes_req += bytes_req; |
Wenji Huang | 4efb529 | 2009-12-21 17:52:55 +0800 | [diff] [blame] | 122 | data->bytes_alloc += bytes_alloc; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 123 | } else { |
| 124 | data = malloc(sizeof(*data)); |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 125 | if (!data) { |
| 126 | pr_err("%s: malloc failed\n", __func__); |
| 127 | return -1; |
| 128 | } |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 129 | data->call_site = call_site; |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 130 | data->pingpong = 0; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 131 | data->hit = 1; |
| 132 | data->bytes_req = bytes_req; |
| 133 | data->bytes_alloc = bytes_alloc; |
| 134 | |
| 135 | rb_link_node(&data->node, parent, node); |
| 136 | rb_insert_color(&data->node, &root_caller_stat); |
| 137 | } |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 138 | |
| 139 | return 0; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 140 | } |
| 141 | |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 142 | static int perf_evsel__process_alloc_event(struct perf_evsel *evsel, |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 143 | struct perf_sample *sample) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 144 | { |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 145 | unsigned long ptr = perf_evsel__intval(evsel, sample, "ptr"), |
| 146 | call_site = perf_evsel__intval(evsel, sample, "call_site"); |
| 147 | int bytes_req = perf_evsel__intval(evsel, sample, "bytes_req"), |
| 148 | bytes_alloc = perf_evsel__intval(evsel, sample, "bytes_alloc"); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 149 | |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 150 | if (insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, sample->cpu) || |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 151 | insert_caller_stat(call_site, bytes_req, bytes_alloc)) |
| 152 | return -1; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 153 | |
| 154 | total_requested += bytes_req; |
| 155 | total_allocated += bytes_alloc; |
Li Zefan | 7d0d394 | 2009-11-24 13:26:31 +0800 | [diff] [blame] | 156 | |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 157 | nr_allocs++; |
| 158 | return 0; |
| 159 | } |
| 160 | |
| 161 | static int perf_evsel__process_alloc_node_event(struct perf_evsel *evsel, |
| 162 | struct perf_sample *sample) |
| 163 | { |
| 164 | int ret = perf_evsel__process_alloc_event(evsel, sample); |
| 165 | |
| 166 | if (!ret) { |
Don Zickus | 4b62795 | 2014-04-07 14:55:23 -0400 | [diff] [blame] | 167 | int node1 = cpu__get_node(sample->cpu), |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 168 | node2 = perf_evsel__intval(evsel, sample, "node"); |
| 169 | |
Li Zefan | 7d0d394 | 2009-11-24 13:26:31 +0800 | [diff] [blame] | 170 | if (node1 != node2) |
| 171 | nr_cross_allocs++; |
| 172 | } |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 173 | |
| 174 | return ret; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 175 | } |
| 176 | |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 177 | static int ptr_cmp(struct alloc_stat *, struct alloc_stat *); |
| 178 | static int callsite_cmp(struct alloc_stat *, struct alloc_stat *); |
| 179 | |
| 180 | static struct alloc_stat *search_alloc_stat(unsigned long ptr, |
| 181 | unsigned long call_site, |
| 182 | struct rb_root *root, |
| 183 | sort_fn_t sort_fn) |
| 184 | { |
| 185 | struct rb_node *node = root->rb_node; |
| 186 | struct alloc_stat key = { .ptr = ptr, .call_site = call_site }; |
| 187 | |
| 188 | while (node) { |
| 189 | struct alloc_stat *data; |
| 190 | int cmp; |
| 191 | |
| 192 | data = rb_entry(node, struct alloc_stat, node); |
| 193 | |
| 194 | cmp = sort_fn(&key, data); |
| 195 | if (cmp < 0) |
| 196 | node = node->rb_left; |
| 197 | else if (cmp > 0) |
| 198 | node = node->rb_right; |
| 199 | else |
| 200 | return data; |
| 201 | } |
| 202 | return NULL; |
| 203 | } |
| 204 | |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 205 | static int perf_evsel__process_free_event(struct perf_evsel *evsel, |
| 206 | struct perf_sample *sample) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 207 | { |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 208 | unsigned long ptr = perf_evsel__intval(evsel, sample, "ptr"); |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 209 | struct alloc_stat *s_alloc, *s_caller; |
| 210 | |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 211 | s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp); |
| 212 | if (!s_alloc) |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 213 | return 0; |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 214 | |
Arnaldo Carvalho de Melo | 22ad798 | 2012-08-07 10:56:43 -0300 | [diff] [blame] | 215 | if ((short)sample->cpu != s_alloc->alloc_cpu) { |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 216 | s_alloc->pingpong++; |
| 217 | |
| 218 | s_caller = search_alloc_stat(0, s_alloc->call_site, |
| 219 | &root_caller_stat, callsite_cmp); |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 220 | if (!s_caller) |
| 221 | return -1; |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 222 | s_caller->pingpong++; |
| 223 | } |
| 224 | s_alloc->alloc_cpu = -1; |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 225 | |
| 226 | return 0; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 227 | } |
| 228 | |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 229 | typedef int (*tracepoint_handler)(struct perf_evsel *evsel, |
| 230 | struct perf_sample *sample); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 231 | |
Irina Tirdea | 1d037ca | 2012-09-11 01:15:03 +0300 | [diff] [blame] | 232 | static int process_sample_event(struct perf_tool *tool __maybe_unused, |
Arnaldo Carvalho de Melo | d20deb6 | 2011-11-25 08:19:45 -0200 | [diff] [blame] | 233 | union perf_event *event, |
Arnaldo Carvalho de Melo | 8115d60 | 2011-01-29 14:01:45 -0200 | [diff] [blame] | 234 | struct perf_sample *sample, |
Arnaldo Carvalho de Melo | fcf65bf | 2012-08-07 09:58:03 -0300 | [diff] [blame] | 235 | struct perf_evsel *evsel, |
Arnaldo Carvalho de Melo | 743eb86 | 2011-11-28 07:56:39 -0200 | [diff] [blame] | 236 | struct machine *machine) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 237 | { |
Adrian Hunter | ef89325 | 2013-08-27 11:23:06 +0300 | [diff] [blame] | 238 | struct thread *thread = machine__findnew_thread(machine, sample->pid, |
Namhyung Kim | 13ce34d | 2014-05-12 09:56:42 +0900 | [diff] [blame] | 239 | sample->tid); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 240 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 241 | if (thread == NULL) { |
| 242 | pr_debug("problem processing %d event, skipping it.\n", |
| 243 | event->header.type); |
| 244 | return -1; |
| 245 | } |
| 246 | |
Frederic Weisbecker | b9c5143 | 2013-09-11 14:46:56 +0200 | [diff] [blame] | 247 | dump_printf(" ... thread: %s:%d\n", thread__comm_str(thread), thread->tid); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 248 | |
Arnaldo Carvalho de Melo | 744a971 | 2013-11-06 10:17:38 -0300 | [diff] [blame] | 249 | if (evsel->handler != NULL) { |
| 250 | tracepoint_handler f = evsel->handler; |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 251 | return f(evsel, sample); |
| 252 | } |
| 253 | |
| 254 | return 0; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 255 | } |
| 256 | |
Arnaldo Carvalho de Melo | fcf65bf | 2012-08-07 09:58:03 -0300 | [diff] [blame] | 257 | static struct perf_tool perf_kmem = { |
| 258 | .sample = process_sample_event, |
| 259 | .comm = perf_event__process_comm, |
Namhyung Kim | 64c4090 | 2014-08-01 14:59:31 +0900 | [diff] [blame] | 260 | .mmap = perf_event__process_mmap, |
| 261 | .mmap2 = perf_event__process_mmap2, |
Jiri Olsa | 0a8cb85 | 2014-07-06 14:18:21 +0200 | [diff] [blame] | 262 | .ordered_events = true, |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 263 | }; |
| 264 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 265 | static double fragmentation(unsigned long n_req, unsigned long n_alloc) |
| 266 | { |
| 267 | if (n_alloc == 0) |
| 268 | return 0.0; |
| 269 | else |
| 270 | return 100.0 - (100.0 * n_req / n_alloc); |
| 271 | } |
| 272 | |
Arnaldo Carvalho de Melo | 4aa6563 | 2009-12-13 19:50:29 -0200 | [diff] [blame] | 273 | static void __print_result(struct rb_root *root, struct perf_session *session, |
| 274 | int n_lines, int is_caller) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 275 | { |
| 276 | struct rb_node *next; |
Arnaldo Carvalho de Melo | 34ba512 | 2012-12-19 09:04:24 -0300 | [diff] [blame] | 277 | struct machine *machine = &session->machines.host; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 278 | |
Namhyung Kim | 65f46e0 | 2015-03-12 16:32:48 +0900 | [diff] [blame] | 279 | printf("%.105s\n", graph_dotted_line); |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 280 | printf(" %-34s |", is_caller ? "Callsite": "Alloc Ptr"); |
Pekka Enberg | 4710327 | 2010-01-19 19:23:23 +0200 | [diff] [blame] | 281 | printf(" Total_alloc/Per | Total_req/Per | Hit | Ping-pong | Frag\n"); |
Namhyung Kim | 65f46e0 | 2015-03-12 16:32:48 +0900 | [diff] [blame] | 282 | printf("%.105s\n", graph_dotted_line); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 283 | |
| 284 | next = rb_first(root); |
| 285 | |
| 286 | while (next && n_lines--) { |
Arnaldo Carvalho de Melo | 1b145ae | 2009-11-23 17:51:09 -0200 | [diff] [blame] | 287 | struct alloc_stat *data = rb_entry(next, struct alloc_stat, |
| 288 | node); |
| 289 | struct symbol *sym = NULL; |
Arnaldo Carvalho de Melo | 71cf8b8 | 2010-04-01 21:24:38 -0300 | [diff] [blame] | 290 | struct map *map; |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 291 | char buf[BUFSIZ]; |
Arnaldo Carvalho de Melo | 1b145ae | 2009-11-23 17:51:09 -0200 | [diff] [blame] | 292 | u64 addr; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 293 | |
Arnaldo Carvalho de Melo | 1b145ae | 2009-11-23 17:51:09 -0200 | [diff] [blame] | 294 | if (is_caller) { |
| 295 | addr = data->call_site; |
Li Zefan | 7707b6b | 2009-11-24 13:25:48 +0800 | [diff] [blame] | 296 | if (!raw_ip) |
Arnaldo Carvalho de Melo | 5c0541d | 2010-04-29 15:25:23 -0300 | [diff] [blame] | 297 | sym = machine__find_kernel_function(machine, addr, &map, NULL); |
Arnaldo Carvalho de Melo | 1b145ae | 2009-11-23 17:51:09 -0200 | [diff] [blame] | 298 | } else |
| 299 | addr = data->ptr; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 300 | |
Arnaldo Carvalho de Melo | 1b145ae | 2009-11-23 17:51:09 -0200 | [diff] [blame] | 301 | if (sym != NULL) |
Arnaldo Carvalho de Melo | 9486aa3 | 2011-01-22 20:37:02 -0200 | [diff] [blame] | 302 | snprintf(buf, sizeof(buf), "%s+%" PRIx64 "", sym->name, |
Arnaldo Carvalho de Melo | 71cf8b8 | 2010-04-01 21:24:38 -0300 | [diff] [blame] | 303 | addr - map->unmap_ip(map, sym->start)); |
Arnaldo Carvalho de Melo | 1b145ae | 2009-11-23 17:51:09 -0200 | [diff] [blame] | 304 | else |
Arnaldo Carvalho de Melo | 9486aa3 | 2011-01-22 20:37:02 -0200 | [diff] [blame] | 305 | snprintf(buf, sizeof(buf), "%#" PRIx64 "", addr); |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 306 | printf(" %-34s |", buf); |
Arnaldo Carvalho de Melo | 1b145ae | 2009-11-23 17:51:09 -0200 | [diff] [blame] | 307 | |
Namhyung Kim | 65f46e0 | 2015-03-12 16:32:48 +0900 | [diff] [blame] | 308 | printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %9lu | %6.3f%%\n", |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 309 | (unsigned long long)data->bytes_alloc, |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 310 | (unsigned long)data->bytes_alloc / data->hit, |
| 311 | (unsigned long long)data->bytes_req, |
| 312 | (unsigned long)data->bytes_req / data->hit, |
| 313 | (unsigned long)data->hit, |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 314 | (unsigned long)data->pingpong, |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 315 | fragmentation(data->bytes_req, data->bytes_alloc)); |
| 316 | |
| 317 | next = rb_next(next); |
| 318 | } |
| 319 | |
| 320 | if (n_lines == -1) |
Namhyung Kim | 65f46e0 | 2015-03-12 16:32:48 +0900 | [diff] [blame] | 321 | printf(" ... | ... | ... | ... | ... | ... \n"); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 322 | |
Namhyung Kim | 65f46e0 | 2015-03-12 16:32:48 +0900 | [diff] [blame] | 323 | printf("%.105s\n", graph_dotted_line); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 324 | } |
| 325 | |
| 326 | static void print_summary(void) |
| 327 | { |
| 328 | printf("\nSUMMARY\n=======\n"); |
Namhyung Kim | 77cfe38 | 2015-03-23 15:30:40 +0900 | [diff] [blame] | 329 | printf("Total bytes requested: %'lu\n", total_requested); |
| 330 | printf("Total bytes allocated: %'lu\n", total_allocated); |
| 331 | printf("Total bytes wasted on internal fragmentation: %'lu\n", |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 332 | total_allocated - total_requested); |
| 333 | printf("Internal fragmentation: %f%%\n", |
| 334 | fragmentation(total_requested, total_allocated)); |
Namhyung Kim | 77cfe38 | 2015-03-23 15:30:40 +0900 | [diff] [blame] | 335 | printf("Cross CPU allocations: %'lu/%'lu\n", nr_cross_allocs, nr_allocs); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 336 | } |
| 337 | |
Arnaldo Carvalho de Melo | 4aa6563 | 2009-12-13 19:50:29 -0200 | [diff] [blame] | 338 | static void print_result(struct perf_session *session) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 339 | { |
| 340 | if (caller_flag) |
Arnaldo Carvalho de Melo | 4aa6563 | 2009-12-13 19:50:29 -0200 | [diff] [blame] | 341 | __print_result(&root_caller_sorted, session, caller_lines, 1); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 342 | if (alloc_flag) |
Arnaldo Carvalho de Melo | 4aa6563 | 2009-12-13 19:50:29 -0200 | [diff] [blame] | 343 | __print_result(&root_alloc_sorted, session, alloc_lines, 0); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 344 | print_summary(); |
| 345 | } |
| 346 | |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 347 | struct sort_dimension { |
| 348 | const char name[20]; |
| 349 | sort_fn_t cmp; |
| 350 | struct list_head list; |
| 351 | }; |
| 352 | |
| 353 | static LIST_HEAD(caller_sort); |
| 354 | static LIST_HEAD(alloc_sort); |
| 355 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 356 | static void sort_insert(struct rb_root *root, struct alloc_stat *data, |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 357 | struct list_head *sort_list) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 358 | { |
| 359 | struct rb_node **new = &(root->rb_node); |
| 360 | struct rb_node *parent = NULL; |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 361 | struct sort_dimension *sort; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 362 | |
| 363 | while (*new) { |
| 364 | struct alloc_stat *this; |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 365 | int cmp = 0; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 366 | |
| 367 | this = rb_entry(*new, struct alloc_stat, node); |
| 368 | parent = *new; |
| 369 | |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 370 | list_for_each_entry(sort, sort_list, list) { |
| 371 | cmp = sort->cmp(data, this); |
| 372 | if (cmp) |
| 373 | break; |
| 374 | } |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 375 | |
| 376 | if (cmp > 0) |
| 377 | new = &((*new)->rb_left); |
| 378 | else |
| 379 | new = &((*new)->rb_right); |
| 380 | } |
| 381 | |
| 382 | rb_link_node(&data->node, parent, new); |
| 383 | rb_insert_color(&data->node, root); |
| 384 | } |
| 385 | |
| 386 | static void __sort_result(struct rb_root *root, struct rb_root *root_sorted, |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 387 | struct list_head *sort_list) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 388 | { |
| 389 | struct rb_node *node; |
| 390 | struct alloc_stat *data; |
| 391 | |
| 392 | for (;;) { |
| 393 | node = rb_first(root); |
| 394 | if (!node) |
| 395 | break; |
| 396 | |
| 397 | rb_erase(node, root); |
| 398 | data = rb_entry(node, struct alloc_stat, node); |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 399 | sort_insert(root_sorted, data, sort_list); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 400 | } |
| 401 | } |
| 402 | |
| 403 | static void sort_result(void) |
| 404 | { |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 405 | __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort); |
| 406 | __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 407 | } |
| 408 | |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 409 | static int __cmd_kmem(struct perf_session *session) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 410 | { |
Arnaldo Carvalho de Melo | d549c769 | 2009-12-27 21:37:02 -0200 | [diff] [blame] | 411 | int err = -EINVAL; |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 412 | const struct perf_evsel_str_handler kmem_tracepoints[] = { |
| 413 | { "kmem:kmalloc", perf_evsel__process_alloc_event, }, |
| 414 | { "kmem:kmem_cache_alloc", perf_evsel__process_alloc_event, }, |
| 415 | { "kmem:kmalloc_node", perf_evsel__process_alloc_node_event, }, |
| 416 | { "kmem:kmem_cache_alloc_node", perf_evsel__process_alloc_node_event, }, |
| 417 | { "kmem:kfree", perf_evsel__process_free_event, }, |
| 418 | { "kmem:kmem_cache_free", perf_evsel__process_free_event, }, |
| 419 | }; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 420 | |
Arnaldo Carvalho de Melo | d549c769 | 2009-12-27 21:37:02 -0200 | [diff] [blame] | 421 | if (!perf_session__has_traces(session, "kmem record")) |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 422 | goto out; |
Arnaldo Carvalho de Melo | d549c769 | 2009-12-27 21:37:02 -0200 | [diff] [blame] | 423 | |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 424 | if (perf_session__set_tracepoints_handlers(session, kmem_tracepoints)) { |
| 425 | pr_err("Initializing perf session tracepoint handlers failed\n"); |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 426 | goto out; |
Arnaldo Carvalho de Melo | 0f7d2f1 | 2012-09-24 10:46:54 -0300 | [diff] [blame] | 427 | } |
| 428 | |
Arnaldo Carvalho de Melo | 4aa6563 | 2009-12-13 19:50:29 -0200 | [diff] [blame] | 429 | setup_pager(); |
Arnaldo Carvalho de Melo | b7b61cb | 2015-03-03 11:58:45 -0300 | [diff] [blame] | 430 | err = perf_session__process_events(session); |
Arnaldo Carvalho de Melo | 4aa6563 | 2009-12-13 19:50:29 -0200 | [diff] [blame] | 431 | if (err != 0) |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 432 | goto out; |
Arnaldo Carvalho de Melo | 4aa6563 | 2009-12-13 19:50:29 -0200 | [diff] [blame] | 433 | sort_result(); |
| 434 | print_result(session); |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 435 | out: |
Arnaldo Carvalho de Melo | 4aa6563 | 2009-12-13 19:50:29 -0200 | [diff] [blame] | 436 | return err; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 437 | } |
| 438 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 439 | static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r) |
| 440 | { |
| 441 | if (l->ptr < r->ptr) |
| 442 | return -1; |
| 443 | else if (l->ptr > r->ptr) |
| 444 | return 1; |
| 445 | return 0; |
| 446 | } |
| 447 | |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 448 | static struct sort_dimension ptr_sort_dimension = { |
| 449 | .name = "ptr", |
| 450 | .cmp = ptr_cmp, |
| 451 | }; |
| 452 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 453 | static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r) |
| 454 | { |
| 455 | if (l->call_site < r->call_site) |
| 456 | return -1; |
| 457 | else if (l->call_site > r->call_site) |
| 458 | return 1; |
| 459 | return 0; |
| 460 | } |
| 461 | |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 462 | static struct sort_dimension callsite_sort_dimension = { |
| 463 | .name = "callsite", |
| 464 | .cmp = callsite_cmp, |
| 465 | }; |
| 466 | |
Pekka Enberg | f3ced7c | 2009-11-22 11:58:00 +0200 | [diff] [blame] | 467 | static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r) |
| 468 | { |
| 469 | if (l->hit < r->hit) |
| 470 | return -1; |
| 471 | else if (l->hit > r->hit) |
| 472 | return 1; |
| 473 | return 0; |
| 474 | } |
| 475 | |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 476 | static struct sort_dimension hit_sort_dimension = { |
| 477 | .name = "hit", |
| 478 | .cmp = hit_cmp, |
| 479 | }; |
| 480 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 481 | static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r) |
| 482 | { |
| 483 | if (l->bytes_alloc < r->bytes_alloc) |
| 484 | return -1; |
| 485 | else if (l->bytes_alloc > r->bytes_alloc) |
| 486 | return 1; |
| 487 | return 0; |
| 488 | } |
| 489 | |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 490 | static struct sort_dimension bytes_sort_dimension = { |
| 491 | .name = "bytes", |
| 492 | .cmp = bytes_cmp, |
| 493 | }; |
| 494 | |
Pekka Enberg | f3ced7c | 2009-11-22 11:58:00 +0200 | [diff] [blame] | 495 | static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r) |
| 496 | { |
| 497 | double x, y; |
| 498 | |
| 499 | x = fragmentation(l->bytes_req, l->bytes_alloc); |
| 500 | y = fragmentation(r->bytes_req, r->bytes_alloc); |
| 501 | |
| 502 | if (x < y) |
| 503 | return -1; |
| 504 | else if (x > y) |
| 505 | return 1; |
| 506 | return 0; |
| 507 | } |
| 508 | |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 509 | static struct sort_dimension frag_sort_dimension = { |
| 510 | .name = "frag", |
| 511 | .cmp = frag_cmp, |
| 512 | }; |
| 513 | |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 514 | static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r) |
| 515 | { |
| 516 | if (l->pingpong < r->pingpong) |
| 517 | return -1; |
| 518 | else if (l->pingpong > r->pingpong) |
| 519 | return 1; |
| 520 | return 0; |
| 521 | } |
| 522 | |
| 523 | static struct sort_dimension pingpong_sort_dimension = { |
| 524 | .name = "pingpong", |
| 525 | .cmp = pingpong_cmp, |
| 526 | }; |
| 527 | |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 528 | static struct sort_dimension *avail_sorts[] = { |
| 529 | &ptr_sort_dimension, |
| 530 | &callsite_sort_dimension, |
| 531 | &hit_sort_dimension, |
| 532 | &bytes_sort_dimension, |
| 533 | &frag_sort_dimension, |
Li Zefan | 079d3f6 | 2009-11-24 13:26:55 +0800 | [diff] [blame] | 534 | &pingpong_sort_dimension, |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 535 | }; |
| 536 | |
Sasha Levin | 49e4ba5 | 2012-12-20 14:11:16 -0500 | [diff] [blame] | 537 | #define NUM_AVAIL_SORTS ((int)ARRAY_SIZE(avail_sorts)) |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 538 | |
| 539 | static int sort_dimension__add(const char *tok, struct list_head *list) |
| 540 | { |
| 541 | struct sort_dimension *sort; |
| 542 | int i; |
| 543 | |
| 544 | for (i = 0; i < NUM_AVAIL_SORTS; i++) { |
| 545 | if (!strcmp(avail_sorts[i]->name, tok)) { |
Arnaldo Carvalho de Melo | 8d9233f | 2013-01-24 22:24:57 -0300 | [diff] [blame] | 546 | sort = memdup(avail_sorts[i], sizeof(*avail_sorts[i])); |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 547 | if (!sort) { |
Arnaldo Carvalho de Melo | 8d9233f | 2013-01-24 22:24:57 -0300 | [diff] [blame] | 548 | pr_err("%s: memdup failed\n", __func__); |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 549 | return -1; |
| 550 | } |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 551 | list_add_tail(&sort->list, list); |
| 552 | return 0; |
| 553 | } |
| 554 | } |
| 555 | |
| 556 | return -1; |
| 557 | } |
| 558 | |
| 559 | static int setup_sorting(struct list_head *sort_list, const char *arg) |
| 560 | { |
| 561 | char *tok; |
| 562 | char *str = strdup(arg); |
Namhyung Kim | 405f875 | 2015-03-12 16:32:46 +0900 | [diff] [blame] | 563 | char *pos = str; |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 564 | |
Arnaldo Carvalho de Melo | 2814eb0 | 2012-09-08 22:53:06 -0300 | [diff] [blame] | 565 | if (!str) { |
| 566 | pr_err("%s: strdup failed\n", __func__); |
| 567 | return -1; |
| 568 | } |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 569 | |
| 570 | while (true) { |
Namhyung Kim | 405f875 | 2015-03-12 16:32:46 +0900 | [diff] [blame] | 571 | tok = strsep(&pos, ","); |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 572 | if (!tok) |
| 573 | break; |
| 574 | if (sort_dimension__add(tok, sort_list) < 0) { |
| 575 | error("Unknown --sort key: '%s'", tok); |
Namhyung Kim | 1b22859 | 2012-01-08 02:25:29 +0900 | [diff] [blame] | 576 | free(str); |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 577 | return -1; |
| 578 | } |
| 579 | } |
| 580 | |
| 581 | free(str); |
| 582 | return 0; |
| 583 | } |
| 584 | |
Irina Tirdea | 1d037ca | 2012-09-11 01:15:03 +0300 | [diff] [blame] | 585 | static int parse_sort_opt(const struct option *opt __maybe_unused, |
| 586 | const char *arg, int unset __maybe_unused) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 587 | { |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 588 | if (!arg) |
| 589 | return -1; |
| 590 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 591 | if (caller_flag > alloc_flag) |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 592 | return setup_sorting(&caller_sort, arg); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 593 | else |
Li Zefan | 29b3e15 | 2009-11-24 13:26:10 +0800 | [diff] [blame] | 594 | return setup_sorting(&alloc_sort, arg); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 595 | |
| 596 | return 0; |
| 597 | } |
| 598 | |
Irina Tirdea | 1d037ca | 2012-09-11 01:15:03 +0300 | [diff] [blame] | 599 | static int parse_caller_opt(const struct option *opt __maybe_unused, |
| 600 | const char *arg __maybe_unused, |
| 601 | int unset __maybe_unused) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 602 | { |
Li Zefan | 90b86a9 | 2009-12-10 15:21:57 +0800 | [diff] [blame] | 603 | caller_flag = (alloc_flag + 1); |
| 604 | return 0; |
| 605 | } |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 606 | |
Irina Tirdea | 1d037ca | 2012-09-11 01:15:03 +0300 | [diff] [blame] | 607 | static int parse_alloc_opt(const struct option *opt __maybe_unused, |
| 608 | const char *arg __maybe_unused, |
| 609 | int unset __maybe_unused) |
Li Zefan | 90b86a9 | 2009-12-10 15:21:57 +0800 | [diff] [blame] | 610 | { |
| 611 | alloc_flag = (caller_flag + 1); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 612 | return 0; |
| 613 | } |
| 614 | |
Irina Tirdea | 1d037ca | 2012-09-11 01:15:03 +0300 | [diff] [blame] | 615 | static int parse_line_opt(const struct option *opt __maybe_unused, |
| 616 | const char *arg, int unset __maybe_unused) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 617 | { |
| 618 | int lines; |
| 619 | |
| 620 | if (!arg) |
| 621 | return -1; |
| 622 | |
| 623 | lines = strtoul(arg, NULL, 10); |
| 624 | |
| 625 | if (caller_flag > alloc_flag) |
| 626 | caller_lines = lines; |
| 627 | else |
| 628 | alloc_lines = lines; |
| 629 | |
| 630 | return 0; |
| 631 | } |
| 632 | |
Arnaldo Carvalho de Melo | 0433ffb | 2012-10-01 15:20:58 -0300 | [diff] [blame] | 633 | static int __cmd_record(int argc, const char **argv) |
| 634 | { |
| 635 | const char * const record_args[] = { |
Jiri Olsa | 4a4d371 | 2013-06-05 13:37:21 +0200 | [diff] [blame] | 636 | "record", "-a", "-R", "-c", "1", |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 637 | "-e", "kmem:kmalloc", |
| 638 | "-e", "kmem:kmalloc_node", |
| 639 | "-e", "kmem:kfree", |
| 640 | "-e", "kmem:kmem_cache_alloc", |
| 641 | "-e", "kmem:kmem_cache_alloc_node", |
| 642 | "-e", "kmem:kmem_cache_free", |
Arnaldo Carvalho de Melo | 0433ffb | 2012-10-01 15:20:58 -0300 | [diff] [blame] | 643 | }; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 644 | unsigned int rec_argc, i, j; |
| 645 | const char **rec_argv; |
| 646 | |
| 647 | rec_argc = ARRAY_SIZE(record_args) + argc - 1; |
| 648 | rec_argv = calloc(rec_argc + 1, sizeof(char *)); |
| 649 | |
Chris Samuel | ce47dc5 | 2010-11-13 13:35:06 +1100 | [diff] [blame] | 650 | if (rec_argv == NULL) |
| 651 | return -ENOMEM; |
| 652 | |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 653 | for (i = 0; i < ARRAY_SIZE(record_args); i++) |
| 654 | rec_argv[i] = strdup(record_args[i]); |
| 655 | |
| 656 | for (j = 1; j < (unsigned int)argc; j++, i++) |
| 657 | rec_argv[i] = argv[j]; |
| 658 | |
| 659 | return cmd_record(i, rec_argv, NULL); |
| 660 | } |
| 661 | |
Irina Tirdea | 1d037ca | 2012-09-11 01:15:03 +0300 | [diff] [blame] | 662 | int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 663 | { |
Arnaldo Carvalho de Melo | 0433ffb | 2012-10-01 15:20:58 -0300 | [diff] [blame] | 664 | const char * const default_sort_order = "frag,hit,bytes"; |
Yunlong Song | d1eeb77 | 2015-04-02 21:47:12 +0800 | [diff] [blame] | 665 | struct perf_data_file file = { |
Yunlong Song | d1eeb77 | 2015-04-02 21:47:12 +0800 | [diff] [blame] | 666 | .mode = PERF_DATA_MODE_READ, |
| 667 | }; |
Arnaldo Carvalho de Melo | 0433ffb | 2012-10-01 15:20:58 -0300 | [diff] [blame] | 668 | const struct option kmem_options[] = { |
| 669 | OPT_STRING('i', "input", &input_name, "file", "input file name"), |
Namhyung Kim | bd72a33 | 2015-03-12 16:32:47 +0900 | [diff] [blame] | 670 | OPT_INCR('v', "verbose", &verbose, |
| 671 | "be more verbose (show symbol address, etc)"), |
Arnaldo Carvalho de Melo | 0433ffb | 2012-10-01 15:20:58 -0300 | [diff] [blame] | 672 | OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL, |
| 673 | "show per-callsite statistics", parse_caller_opt), |
| 674 | OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL, |
| 675 | "show per-allocation statistics", parse_alloc_opt), |
| 676 | OPT_CALLBACK('s', "sort", NULL, "key[,key2...]", |
| 677 | "sort by keys: ptr, call_site, bytes, hit, pingpong, frag", |
| 678 | parse_sort_opt), |
| 679 | OPT_CALLBACK('l', "line", NULL, "num", "show n lines", parse_line_opt), |
| 680 | OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"), |
Yunlong Song | d1eeb77 | 2015-04-02 21:47:12 +0800 | [diff] [blame] | 681 | OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"), |
Arnaldo Carvalho de Melo | 0433ffb | 2012-10-01 15:20:58 -0300 | [diff] [blame] | 682 | OPT_END() |
| 683 | }; |
Ramkumar Ramachandra | 3bca235 | 2014-03-14 23:17:51 -0400 | [diff] [blame] | 684 | const char *const kmem_subcommands[] = { "record", "stat", NULL }; |
| 685 | const char *kmem_usage[] = { |
| 686 | NULL, |
Arnaldo Carvalho de Melo | 0433ffb | 2012-10-01 15:20:58 -0300 | [diff] [blame] | 687 | NULL |
| 688 | }; |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 689 | struct perf_session *session; |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 690 | int ret = -1; |
| 691 | |
Ramkumar Ramachandra | 3bca235 | 2014-03-14 23:17:51 -0400 | [diff] [blame] | 692 | argc = parse_options_subcommand(argc, argv, kmem_options, |
| 693 | kmem_subcommands, kmem_usage, 0); |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 694 | |
Li Zefan | 90b86a9 | 2009-12-10 15:21:57 +0800 | [diff] [blame] | 695 | if (!argc) |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 696 | usage_with_options(kmem_usage, kmem_options); |
| 697 | |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 698 | if (!strncmp(argv[0], "rec", 3)) { |
Namhyung Kim | 0a7e6d1 | 2014-08-12 15:40:45 +0900 | [diff] [blame] | 699 | symbol__init(NULL); |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 700 | return __cmd_record(argc, argv); |
| 701 | } |
| 702 | |
Jiri Olsa | 28939e1 | 2015-04-06 14:36:08 +0900 | [diff] [blame^] | 703 | file.path = input_name; |
| 704 | |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 705 | session = perf_session__new(&file, false, &perf_kmem); |
| 706 | if (session == NULL) |
Taeung Song | 52e02834 | 2014-09-24 10:33:37 +0900 | [diff] [blame] | 707 | return -1; |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 708 | |
Namhyung Kim | 0a7e6d1 | 2014-08-12 15:40:45 +0900 | [diff] [blame] | 709 | symbol__init(&session->header.env); |
Arnaldo Carvalho de Melo | 655000e | 2009-12-15 20:04:40 -0200 | [diff] [blame] | 710 | |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 711 | if (!strcmp(argv[0], "stat")) { |
Namhyung Kim | 77cfe38 | 2015-03-23 15:30:40 +0900 | [diff] [blame] | 712 | setlocale(LC_ALL, ""); |
| 713 | |
Don Zickus | 4b62795 | 2014-04-07 14:55:23 -0400 | [diff] [blame] | 714 | if (cpu__setup_cpunode_map()) |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 715 | goto out_delete; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 716 | |
Li Zefan | 90b86a9 | 2009-12-10 15:21:57 +0800 | [diff] [blame] | 717 | if (list_empty(&caller_sort)) |
| 718 | setup_sorting(&caller_sort, default_sort_order); |
| 719 | if (list_empty(&alloc_sort)) |
| 720 | setup_sorting(&alloc_sort, default_sort_order); |
Li Zefan | 7d0d394 | 2009-11-24 13:26:31 +0800 | [diff] [blame] | 721 | |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 722 | ret = __cmd_kmem(session); |
Pekka Enberg | b00eca8 | 2010-01-19 19:26:11 +0200 | [diff] [blame] | 723 | } else |
| 724 | usage_with_options(kmem_usage, kmem_options); |
Li Zefan | 90b86a9 | 2009-12-10 15:21:57 +0800 | [diff] [blame] | 725 | |
Namhyung Kim | 2b2b2c6 | 2014-08-12 15:40:38 +0900 | [diff] [blame] | 726 | out_delete: |
| 727 | perf_session__delete(session); |
| 728 | |
| 729 | return ret; |
Li Zefan | ba77c9e | 2009-11-20 15:53:25 +0800 | [diff] [blame] | 730 | } |
| 731 | |