]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
fd20e811 | 2 | #include <inttypes.h> |
ea251d51 | 3 | #include <math.h> |
f2a39fe8 ACM |
4 | #include <stdlib.h> |
5 | #include <string.h> | |
2c5d4b4a | 6 | #include <linux/compiler.h> |
ea251d51 | 7 | |
b10ba7f1 | 8 | #include "../util/callchain.h" |
b4209025 | 9 | #include "../util/debug.h" |
ea251d51 | 10 | #include "../util/hist.h" |
ea251d51 | 11 | #include "../util/sort.h" |
4fb71074 | 12 | #include "../util/evsel.h" |
c3bc0c43 | 13 | #include "../util/evlist.h" |
c1a604df | 14 | #include "../perf.h" |
ea251d51 NK |
15 | |
16 | /* hist period print (hpp) functions */ | |
ea251d51 | 17 | |
a0088adc NK |
18 | #define hpp__call_print_fn(hpp, fn, fmt, ...) \ |
19 | ({ \ | |
20 | int __ret = fn(hpp, fmt, ##__VA_ARGS__); \ | |
21 | advance_hpp(hpp, __ret); \ | |
22 | __ret; \ | |
23 | }) | |
24 | ||
5b591669 NK |
25 | static int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he, |
26 | hpp_field_fn get_field, const char *fmt, int len, | |
27 | hpp_snprint_fn print_fn, bool fmt_percent) | |
ea251d51 | 28 | { |
fb821c9e | 29 | int ret; |
b5ff71c3 | 30 | struct hists *hists = he->hists; |
32dcd021 | 31 | struct evsel *evsel = hists_to_evsel(hists); |
a0088adc NK |
32 | char *buf = hpp->buf; |
33 | size_t size = hpp->size; | |
ea251d51 | 34 | |
0c5268bf JO |
35 | if (fmt_percent) { |
36 | double percent = 0.0; | |
f2148330 | 37 | u64 total = hists__total_period(hists); |
9ffad987 | 38 | |
f2148330 NK |
39 | if (total) |
40 | percent = 100.0 * get_field(he) / total; | |
0c5268bf | 41 | |
d675107c | 42 | ret = hpp__call_print_fn(hpp, print_fn, fmt, len, percent); |
0c5268bf | 43 | } else |
d675107c | 44 | ret = hpp__call_print_fn(hpp, print_fn, fmt, len, get_field(he)); |
5b9e2146 | 45 | |
c754c382 | 46 | if (evsel__is_group_event(evsel)) { |
5b9e2146 | 47 | int prev_idx, idx_delta; |
5b9e2146 | 48 | struct hist_entry *pair; |
5643b1a5 | 49 | int nr_members = evsel->core.nr_members; |
5b9e2146 | 50 | |
2bb72dbb | 51 | prev_idx = evsel__group_idx(evsel); |
5b9e2146 NK |
52 | |
53 | list_for_each_entry(pair, &he->pairs.head, pairs.node) { | |
54 | u64 period = get_field(pair); | |
f2148330 | 55 | u64 total = hists__total_period(pair->hists); |
5b9e2146 NK |
56 | |
57 | if (!total) | |
58 | continue; | |
59 | ||
60 | evsel = hists_to_evsel(pair->hists); | |
2bb72dbb | 61 | idx_delta = evsel__group_idx(evsel) - prev_idx - 1; |
5b9e2146 NK |
62 | |
63 | while (idx_delta--) { | |
64 | /* | |
65 | * zero-fill group members in the middle which | |
66 | * have no sample | |
67 | */ | |
9b0d2fb8 | 68 | if (fmt_percent) { |
a0088adc | 69 | ret += hpp__call_print_fn(hpp, print_fn, |
d675107c | 70 | fmt, len, 0.0); |
9b0d2fb8 | 71 | } else { |
a0088adc | 72 | ret += hpp__call_print_fn(hpp, print_fn, |
d675107c | 73 | fmt, len, 0ULL); |
9b0d2fb8 | 74 | } |
5b9e2146 NK |
75 | } |
76 | ||
a0088adc | 77 | if (fmt_percent) { |
d675107c | 78 | ret += hpp__call_print_fn(hpp, print_fn, fmt, len, |
a0088adc NK |
79 | 100.0 * period / total); |
80 | } else { | |
81 | ret += hpp__call_print_fn(hpp, print_fn, fmt, | |
d675107c | 82 | len, period); |
a0088adc | 83 | } |
5b9e2146 | 84 | |
2bb72dbb | 85 | prev_idx = evsel__group_idx(evsel); |
5b9e2146 NK |
86 | } |
87 | ||
88 | idx_delta = nr_members - prev_idx - 1; | |
89 | ||
90 | while (idx_delta--) { | |
91 | /* | |
92 | * zero-fill group members at last which have no sample | |
93 | */ | |
9b0d2fb8 | 94 | if (fmt_percent) { |
a0088adc | 95 | ret += hpp__call_print_fn(hpp, print_fn, |
d675107c | 96 | fmt, len, 0.0); |
9b0d2fb8 | 97 | } else { |
a0088adc | 98 | ret += hpp__call_print_fn(hpp, print_fn, |
d675107c | 99 | fmt, len, 0ULL); |
9b0d2fb8 | 100 | } |
5b9e2146 NK |
101 | } |
102 | } | |
a0088adc NK |
103 | |
104 | /* | |
105 | * Restore original buf and size as it's where caller expects | |
106 | * the result will be saved. | |
107 | */ | |
108 | hpp->buf = buf; | |
109 | hpp->size = size; | |
110 | ||
4fb71074 | 111 | return ret; |
ea251d51 NK |
112 | } |
113 | ||
5b591669 NK |
114 | int hpp__fmt(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, |
115 | struct hist_entry *he, hpp_field_fn get_field, | |
116 | const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent) | |
117 | { | |
118 | int len = fmt->user_len ?: fmt->len; | |
119 | ||
120 | if (symbol_conf.field_sep) { | |
121 | return __hpp__fmt(hpp, he, get_field, fmtstr, 1, | |
122 | print_fn, fmt_percent); | |
123 | } | |
124 | ||
125 | if (fmt_percent) | |
126 | len -= 2; /* 2 for a space and a % sign */ | |
127 | else | |
128 | len -= 1; | |
129 | ||
130 | return __hpp__fmt(hpp, he, get_field, fmtstr, len, print_fn, fmt_percent); | |
131 | } | |
132 | ||
133 | int hpp__fmt_acc(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, | |
134 | struct hist_entry *he, hpp_field_fn get_field, | |
135 | const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent) | |
594dcbf3 NK |
136 | { |
137 | if (!symbol_conf.cumulate_callchain) { | |
5b591669 NK |
138 | int len = fmt->user_len ?: fmt->len; |
139 | return snprintf(hpp->buf, hpp->size, " %*s", len - 1, "N/A"); | |
594dcbf3 NK |
140 | } |
141 | ||
5b591669 | 142 | return hpp__fmt(fmt, hpp, he, get_field, fmtstr, print_fn, fmt_percent); |
594dcbf3 NK |
143 | } |
144 | ||
f156d84e NK |
145 | static int field_cmp(u64 field_a, u64 field_b) |
146 | { | |
147 | if (field_a > field_b) | |
148 | return 1; | |
149 | if (field_a < field_b) | |
150 | return -1; | |
151 | return 0; | |
152 | } | |
153 | ||
429a5f9d JY |
154 | static int hist_entry__new_pair(struct hist_entry *a, struct hist_entry *b, |
155 | hpp_field_fn get_field, int nr_members, | |
156 | u64 **fields_a, u64 **fields_b) | |
157 | { | |
158 | u64 *fa = calloc(nr_members, sizeof(*fa)), | |
159 | *fb = calloc(nr_members, sizeof(*fb)); | |
160 | struct hist_entry *pair; | |
161 | ||
162 | if (!fa || !fb) | |
163 | goto out_free; | |
164 | ||
165 | list_for_each_entry(pair, &a->pairs.head, pairs.node) { | |
166 | struct evsel *evsel = hists_to_evsel(pair->hists); | |
2bb72dbb | 167 | fa[evsel__group_idx(evsel)] = get_field(pair); |
429a5f9d JY |
168 | } |
169 | ||
170 | list_for_each_entry(pair, &b->pairs.head, pairs.node) { | |
171 | struct evsel *evsel = hists_to_evsel(pair->hists); | |
2bb72dbb | 172 | fb[evsel__group_idx(evsel)] = get_field(pair); |
429a5f9d JY |
173 | } |
174 | ||
175 | *fields_a = fa; | |
176 | *fields_b = fb; | |
177 | return 0; | |
178 | out_free: | |
179 | free(fa); | |
180 | free(fb); | |
181 | *fields_a = *fields_b = NULL; | |
182 | return -1; | |
183 | } | |
184 | ||
185 | static int __hpp__group_sort_idx(struct hist_entry *a, struct hist_entry *b, | |
186 | hpp_field_fn get_field, int idx) | |
187 | { | |
188 | struct evsel *evsel = hists_to_evsel(a->hists); | |
189 | u64 *fields_a, *fields_b; | |
190 | int cmp, nr_members, ret, i; | |
191 | ||
192 | cmp = field_cmp(get_field(a), get_field(b)); | |
c754c382 | 193 | if (!evsel__is_group_event(evsel)) |
429a5f9d JY |
194 | return cmp; |
195 | ||
196 | nr_members = evsel->core.nr_members; | |
197 | if (idx < 1 || idx >= nr_members) | |
198 | return cmp; | |
199 | ||
200 | ret = hist_entry__new_pair(a, b, get_field, nr_members, &fields_a, &fields_b); | |
201 | if (ret) { | |
202 | ret = cmp; | |
203 | goto out; | |
204 | } | |
205 | ||
206 | ret = field_cmp(fields_a[idx], fields_b[idx]); | |
207 | if (ret) | |
208 | goto out; | |
209 | ||
210 | for (i = 1; i < nr_members; i++) { | |
211 | if (i != idx) { | |
212 | ret = field_cmp(fields_a[i], fields_b[i]); | |
213 | if (ret) | |
214 | goto out; | |
215 | } | |
216 | } | |
217 | ||
218 | out: | |
219 | free(fields_a); | |
220 | free(fields_b); | |
221 | ||
222 | return ret; | |
223 | } | |
224 | ||
f156d84e NK |
225 | static int __hpp__sort(struct hist_entry *a, struct hist_entry *b, |
226 | hpp_field_fn get_field) | |
227 | { | |
228 | s64 ret; | |
229 | int i, nr_members; | |
32dcd021 | 230 | struct evsel *evsel; |
f156d84e NK |
231 | u64 *fields_a, *fields_b; |
232 | ||
429a5f9d JY |
233 | if (symbol_conf.group_sort_idx && symbol_conf.event_group) { |
234 | return __hpp__group_sort_idx(a, b, get_field, | |
235 | symbol_conf.group_sort_idx); | |
236 | } | |
237 | ||
f156d84e NK |
238 | ret = field_cmp(get_field(a), get_field(b)); |
239 | if (ret || !symbol_conf.event_group) | |
240 | return ret; | |
241 | ||
242 | evsel = hists_to_evsel(a->hists); | |
c754c382 | 243 | if (!evsel__is_group_event(evsel)) |
f156d84e NK |
244 | return ret; |
245 | ||
5643b1a5 | 246 | nr_members = evsel->core.nr_members; |
429a5f9d JY |
247 | i = hist_entry__new_pair(a, b, get_field, nr_members, &fields_a, &fields_b); |
248 | if (i) | |
f156d84e NK |
249 | goto out; |
250 | ||
f156d84e NK |
251 | for (i = 1; i < nr_members; i++) { |
252 | ret = field_cmp(fields_a[i], fields_b[i]); | |
253 | if (ret) | |
254 | break; | |
255 | } | |
256 | ||
257 | out: | |
258 | free(fields_a); | |
259 | free(fields_b); | |
260 | ||
261 | return ret; | |
262 | } | |
263 | ||
594dcbf3 NK |
264 | static int __hpp__sort_acc(struct hist_entry *a, struct hist_entry *b, |
265 | hpp_field_fn get_field) | |
266 | { | |
267 | s64 ret = 0; | |
268 | ||
269 | if (symbol_conf.cumulate_callchain) { | |
270 | /* | |
271 | * Put caller above callee when they have equal period. | |
272 | */ | |
273 | ret = field_cmp(get_field(a), get_field(b)); | |
274 | if (ret) | |
275 | return ret; | |
276 | ||
fabd37b8 | 277 | if (a->thread != b->thread || !hist_entry__has_callchains(a) || !symbol_conf.use_callchain) |
5ca82710 NK |
278 | return 0; |
279 | ||
594dcbf3 | 280 | ret = b->callchain->max_depth - a->callchain->max_depth; |
7111ffff NK |
281 | if (callchain_param.order == ORDER_CALLER) |
282 | ret = -ret; | |
594dcbf3 NK |
283 | } |
284 | return ret; | |
285 | } | |
286 | ||
1ecd4453 NK |
287 | static int hpp__width_fn(struct perf_hpp_fmt *fmt, |
288 | struct perf_hpp *hpp __maybe_unused, | |
da1b0407 | 289 | struct hists *hists) |
1ecd4453 NK |
290 | { |
291 | int len = fmt->user_len ?: fmt->len; | |
32dcd021 | 292 | struct evsel *evsel = hists_to_evsel(hists); |
1ecd4453 NK |
293 | |
294 | if (symbol_conf.event_group) | |
5643b1a5 | 295 | len = max(len, evsel->core.nr_members * fmt->len); |
1ecd4453 NK |
296 | |
297 | if (len < (int)strlen(fmt->name)) | |
298 | len = strlen(fmt->name); | |
299 | ||
300 | return len; | |
ea251d51 NK |
301 | } |
302 | ||
1ecd4453 | 303 | static int hpp__header_fn(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, |
29659ab4 JO |
304 | struct hists *hists, int line __maybe_unused, |
305 | int *span __maybe_unused) | |
1ecd4453 | 306 | { |
da1b0407 | 307 | int len = hpp__width_fn(fmt, hpp, hists); |
1ecd4453 | 308 | return scnprintf(hpp->buf, hpp->size, "%*s", len, fmt->name); |
e0d66c74 NK |
309 | } |
310 | ||
98ba1609 | 311 | int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) |
a0088adc NK |
312 | { |
313 | va_list args; | |
314 | ssize_t ssize = hpp->size; | |
315 | double percent; | |
d675107c | 316 | int ret, len; |
a0088adc NK |
317 | |
318 | va_start(args, fmt); | |
d675107c | 319 | len = va_arg(args, int); |
a0088adc | 320 | percent = va_arg(args, double); |
d675107c | 321 | ret = percent_color_len_snprintf(hpp->buf, hpp->size, fmt, len, percent); |
a0088adc NK |
322 | va_end(args); |
323 | ||
324 | return (ret >= ssize) ? (ssize - 1) : ret; | |
325 | } | |
326 | ||
327 | static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) | |
328 | { | |
329 | va_list args; | |
330 | ssize_t ssize = hpp->size; | |
331 | int ret; | |
332 | ||
333 | va_start(args, fmt); | |
334 | ret = vsnprintf(hpp->buf, hpp->size, fmt, args); | |
335 | va_end(args); | |
336 | ||
337 | return (ret >= ssize) ? (ssize - 1) : ret; | |
338 | } | |
339 | ||
4fb71074 NK |
340 | #define __HPP_COLOR_PERCENT_FN(_type, _field) \ |
341 | static u64 he_get_##_field(struct hist_entry *he) \ | |
342 | { \ | |
343 | return he->stat._field; \ | |
344 | } \ | |
345 | \ | |
e0d66c74 | 346 | static int hpp__color_##_type(struct perf_hpp_fmt *fmt, \ |
2c5d4b4a | 347 | struct perf_hpp *hpp, struct hist_entry *he) \ |
4fb71074 | 348 | { \ |
5b591669 NK |
349 | return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%", \ |
350 | hpp_color_scnprintf, true); \ | |
ea251d51 NK |
351 | } |
352 | ||
4fb71074 | 353 | #define __HPP_ENTRY_PERCENT_FN(_type, _field) \ |
e0d66c74 | 354 | static int hpp__entry_##_type(struct perf_hpp_fmt *fmt, \ |
2c5d4b4a | 355 | struct perf_hpp *hpp, struct hist_entry *he) \ |
4fb71074 | 356 | { \ |
5b591669 NK |
357 | return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%", \ |
358 | hpp_entry_scnprintf, true); \ | |
ea251d51 NK |
359 | } |
360 | ||
bc18b7f2 | 361 | #define __HPP_SORT_FN(_type, _field) \ |
87bbdf76 NK |
362 | static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ |
363 | struct hist_entry *a, struct hist_entry *b) \ | |
bc18b7f2 | 364 | { \ |
f156d84e | 365 | return __hpp__sort(a, b, he_get_##_field); \ |
bc18b7f2 NK |
366 | } |
367 | ||
594dcbf3 NK |
368 | #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \ |
369 | static u64 he_get_acc_##_field(struct hist_entry *he) \ | |
370 | { \ | |
371 | return he->stat_acc->_field; \ | |
372 | } \ | |
373 | \ | |
e0d66c74 | 374 | static int hpp__color_##_type(struct perf_hpp_fmt *fmt, \ |
594dcbf3 NK |
375 | struct perf_hpp *hpp, struct hist_entry *he) \ |
376 | { \ | |
5b591669 NK |
377 | return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%", \ |
378 | hpp_color_scnprintf, true); \ | |
594dcbf3 NK |
379 | } |
380 | ||
381 | #define __HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \ | |
e0d66c74 | 382 | static int hpp__entry_##_type(struct perf_hpp_fmt *fmt, \ |
594dcbf3 NK |
383 | struct perf_hpp *hpp, struct hist_entry *he) \ |
384 | { \ | |
2bfa1528 | 385 | return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%", \ |
5b591669 | 386 | hpp_entry_scnprintf, true); \ |
594dcbf3 NK |
387 | } |
388 | ||
389 | #define __HPP_SORT_ACC_FN(_type, _field) \ | |
87bbdf76 NK |
390 | static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ |
391 | struct hist_entry *a, struct hist_entry *b) \ | |
594dcbf3 NK |
392 | { \ |
393 | return __hpp__sort_acc(a, b, he_get_acc_##_field); \ | |
394 | } | |
395 | ||
4fb71074 NK |
396 | #define __HPP_ENTRY_RAW_FN(_type, _field) \ |
397 | static u64 he_get_raw_##_field(struct hist_entry *he) \ | |
398 | { \ | |
399 | return he->stat._field; \ | |
400 | } \ | |
401 | \ | |
e0d66c74 | 402 | static int hpp__entry_##_type(struct perf_hpp_fmt *fmt, \ |
2c5d4b4a | 403 | struct perf_hpp *hpp, struct hist_entry *he) \ |
4fb71074 | 404 | { \ |
5b591669 NK |
405 | return hpp__fmt(fmt, hpp, he, he_get_raw_##_field, " %*"PRIu64, \ |
406 | hpp_entry_scnprintf, false); \ | |
ea251d51 NK |
407 | } |
408 | ||
bc18b7f2 | 409 | #define __HPP_SORT_RAW_FN(_type, _field) \ |
87bbdf76 NK |
410 | static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ |
411 | struct hist_entry *a, struct hist_entry *b) \ | |
bc18b7f2 | 412 | { \ |
f156d84e | 413 | return __hpp__sort(a, b, he_get_raw_##_field); \ |
bc18b7f2 NK |
414 | } |
415 | ||
416 | ||
1ecd4453 | 417 | #define HPP_PERCENT_FNS(_type, _field) \ |
4fb71074 | 418 | __HPP_COLOR_PERCENT_FN(_type, _field) \ |
bc18b7f2 NK |
419 | __HPP_ENTRY_PERCENT_FN(_type, _field) \ |
420 | __HPP_SORT_FN(_type, _field) | |
ea251d51 | 421 | |
1ecd4453 | 422 | #define HPP_PERCENT_ACC_FNS(_type, _field) \ |
594dcbf3 NK |
423 | __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \ |
424 | __HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \ | |
425 | __HPP_SORT_ACC_FN(_type, _field) | |
426 | ||
1ecd4453 | 427 | #define HPP_RAW_FNS(_type, _field) \ |
bc18b7f2 NK |
428 | __HPP_ENTRY_RAW_FN(_type, _field) \ |
429 | __HPP_SORT_RAW_FN(_type, _field) | |
ea251d51 | 430 | |
1ecd4453 NK |
431 | HPP_PERCENT_FNS(overhead, period) |
432 | HPP_PERCENT_FNS(overhead_sys, period_sys) | |
433 | HPP_PERCENT_FNS(overhead_us, period_us) | |
434 | HPP_PERCENT_FNS(overhead_guest_sys, period_guest_sys) | |
435 | HPP_PERCENT_FNS(overhead_guest_us, period_guest_us) | |
436 | HPP_PERCENT_ACC_FNS(overhead_acc, period) | |
b5ff71c3 | 437 | |
1ecd4453 NK |
438 | HPP_RAW_FNS(samples, nr_events) |
439 | HPP_RAW_FNS(period, period) | |
9ffad987 | 440 | |
87bbdf76 NK |
441 | static int64_t hpp__nop_cmp(struct perf_hpp_fmt *fmt __maybe_unused, |
442 | struct hist_entry *a __maybe_unused, | |
bc18b7f2 NK |
443 | struct hist_entry *b __maybe_unused) |
444 | { | |
445 | return 0; | |
446 | } | |
447 | ||
c0020efa JO |
448 | static bool perf_hpp__is_hpp_entry(struct perf_hpp_fmt *a) |
449 | { | |
450 | return a->header == hpp__header_fn; | |
451 | } | |
452 | ||
453 | static bool hpp__equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b) | |
454 | { | |
455 | if (!perf_hpp__is_hpp_entry(a) || !perf_hpp__is_hpp_entry(b)) | |
456 | return false; | |
457 | ||
458 | return a->idx == b->idx; | |
459 | } | |
460 | ||
b21a763e | 461 | #define HPP__COLOR_PRINT_FNS(_name, _fn, _idx) \ |
1240005e | 462 | { \ |
1ecd4453 NK |
463 | .name = _name, \ |
464 | .header = hpp__header_fn, \ | |
465 | .width = hpp__width_fn, \ | |
466 | .color = hpp__color_ ## _fn, \ | |
467 | .entry = hpp__entry_ ## _fn, \ | |
bc18b7f2 NK |
468 | .cmp = hpp__nop_cmp, \ |
469 | .collapse = hpp__nop_cmp, \ | |
1ecd4453 | 470 | .sort = hpp__sort_ ## _fn, \ |
b21a763e | 471 | .idx = PERF_HPP__ ## _idx, \ |
c0020efa | 472 | .equal = hpp__equal, \ |
1240005e | 473 | } |
ea251d51 | 474 | |
b21a763e | 475 | #define HPP__COLOR_ACC_PRINT_FNS(_name, _fn, _idx) \ |
594dcbf3 | 476 | { \ |
1ecd4453 NK |
477 | .name = _name, \ |
478 | .header = hpp__header_fn, \ | |
479 | .width = hpp__width_fn, \ | |
480 | .color = hpp__color_ ## _fn, \ | |
481 | .entry = hpp__entry_ ## _fn, \ | |
594dcbf3 NK |
482 | .cmp = hpp__nop_cmp, \ |
483 | .collapse = hpp__nop_cmp, \ | |
1ecd4453 | 484 | .sort = hpp__sort_ ## _fn, \ |
b21a763e | 485 | .idx = PERF_HPP__ ## _idx, \ |
c0020efa | 486 | .equal = hpp__equal, \ |
594dcbf3 NK |
487 | } |
488 | ||
b21a763e | 489 | #define HPP__PRINT_FNS(_name, _fn, _idx) \ |
1240005e | 490 | { \ |
1ecd4453 NK |
491 | .name = _name, \ |
492 | .header = hpp__header_fn, \ | |
493 | .width = hpp__width_fn, \ | |
494 | .entry = hpp__entry_ ## _fn, \ | |
bc18b7f2 NK |
495 | .cmp = hpp__nop_cmp, \ |
496 | .collapse = hpp__nop_cmp, \ | |
1ecd4453 | 497 | .sort = hpp__sort_ ## _fn, \ |
b21a763e | 498 | .idx = PERF_HPP__ ## _idx, \ |
c0020efa | 499 | .equal = hpp__equal, \ |
1240005e | 500 | } |
ea251d51 NK |
501 | |
502 | struct perf_hpp_fmt perf_hpp__format[] = { | |
b21a763e JO |
503 | HPP__COLOR_PRINT_FNS("Overhead", overhead, OVERHEAD), |
504 | HPP__COLOR_PRINT_FNS("sys", overhead_sys, OVERHEAD_SYS), | |
505 | HPP__COLOR_PRINT_FNS("usr", overhead_us, OVERHEAD_US), | |
506 | HPP__COLOR_PRINT_FNS("guest sys", overhead_guest_sys, OVERHEAD_GUEST_SYS), | |
507 | HPP__COLOR_PRINT_FNS("guest usr", overhead_guest_us, OVERHEAD_GUEST_US), | |
508 | HPP__COLOR_ACC_PRINT_FNS("Children", overhead_acc, OVERHEAD_ACC), | |
509 | HPP__PRINT_FNS("Samples", samples, SAMPLES), | |
510 | HPP__PRINT_FNS("Period", period, PERIOD) | |
ea251d51 NK |
511 | }; |
512 | ||
7c31e102 JO |
513 | struct perf_hpp_list perf_hpp_list = { |
514 | .fields = LIST_HEAD_INIT(perf_hpp_list.fields), | |
515 | .sorts = LIST_HEAD_INIT(perf_hpp_list.sorts), | |
f8e6710d | 516 | .nr_header_lines = 1, |
7c31e102 | 517 | }; |
4fb71074 | 518 | |
ea251d51 | 519 | #undef HPP__COLOR_PRINT_FNS |
594dcbf3 | 520 | #undef HPP__COLOR_ACC_PRINT_FNS |
ea251d51 NK |
521 | #undef HPP__PRINT_FNS |
522 | ||
4fb71074 | 523 | #undef HPP_PERCENT_FNS |
594dcbf3 | 524 | #undef HPP_PERCENT_ACC_FNS |
4fb71074 NK |
525 | #undef HPP_RAW_FNS |
526 | ||
527 | #undef __HPP_HEADER_FN | |
528 | #undef __HPP_WIDTH_FN | |
529 | #undef __HPP_COLOR_PERCENT_FN | |
530 | #undef __HPP_ENTRY_PERCENT_FN | |
594dcbf3 NK |
531 | #undef __HPP_COLOR_ACC_PERCENT_FN |
532 | #undef __HPP_ENTRY_ACC_PERCENT_FN | |
4fb71074 | 533 | #undef __HPP_ENTRY_RAW_FN |
594dcbf3 NK |
534 | #undef __HPP_SORT_FN |
535 | #undef __HPP_SORT_ACC_FN | |
536 | #undef __HPP_SORT_RAW_FN | |
4fb71074 NK |
537 | |
538 | ||
1d77822e | 539 | void perf_hpp__init(void) |
ea251d51 | 540 | { |
26d8b338 NK |
541 | int i; |
542 | ||
543 | for (i = 0; i < PERF_HPP__MAX_INDEX; i++) { | |
a2ce067e NK |
544 | struct perf_hpp_fmt *fmt = &perf_hpp__format[i]; |
545 | ||
546 | INIT_LIST_HEAD(&fmt->list); | |
547 | ||
548 | /* sort_list may be linked by setup_sorting() */ | |
549 | if (fmt->sort_list.next == NULL) | |
550 | INIT_LIST_HEAD(&fmt->sort_list); | |
26d8b338 NK |
551 | } |
552 | ||
a7d945bc NK |
553 | /* |
554 | * If user specified field order, no need to setup default fields. | |
555 | */ | |
2f3f9bcf | 556 | if (is_strict_order(field_order)) |
a7d945bc NK |
557 | return; |
558 | ||
594dcbf3 | 559 | if (symbol_conf.cumulate_callchain) { |
1178bfd4 | 560 | hpp_dimension__add_output(PERF_HPP__OVERHEAD_ACC); |
1ecd4453 | 561 | perf_hpp__format[PERF_HPP__OVERHEAD].name = "Self"; |
594dcbf3 NK |
562 | } |
563 | ||
1178bfd4 | 564 | hpp_dimension__add_output(PERF_HPP__OVERHEAD); |
2b8bfa6b | 565 | |
ea251d51 | 566 | if (symbol_conf.show_cpu_utilization) { |
1178bfd4 JO |
567 | hpp_dimension__add_output(PERF_HPP__OVERHEAD_SYS); |
568 | hpp_dimension__add_output(PERF_HPP__OVERHEAD_US); | |
ea251d51 NK |
569 | |
570 | if (perf_guest) { | |
1178bfd4 JO |
571 | hpp_dimension__add_output(PERF_HPP__OVERHEAD_GUEST_SYS); |
572 | hpp_dimension__add_output(PERF_HPP__OVERHEAD_GUEST_US); | |
ea251d51 NK |
573 | } |
574 | } | |
575 | ||
576 | if (symbol_conf.show_nr_samples) | |
1178bfd4 | 577 | hpp_dimension__add_output(PERF_HPP__SAMPLES); |
ea251d51 NK |
578 | |
579 | if (symbol_conf.show_total_period) | |
1178bfd4 | 580 | hpp_dimension__add_output(PERF_HPP__PERIOD); |
1d77822e | 581 | } |
ea251d51 | 582 | |
ebdd98e0 JO |
583 | void perf_hpp_list__column_register(struct perf_hpp_list *list, |
584 | struct perf_hpp_fmt *format) | |
1240005e | 585 | { |
ebdd98e0 | 586 | list_add_tail(&format->list, &list->fields); |
1240005e JO |
587 | } |
588 | ||
ebdd98e0 JO |
589 | void perf_hpp_list__register_sort_field(struct perf_hpp_list *list, |
590 | struct perf_hpp_fmt *format) | |
77284de3 | 591 | { |
ebdd98e0 | 592 | list_add_tail(&format->sort_list, &list->sorts); |
77284de3 NK |
593 | } |
594 | ||
a1c9f97f NK |
595 | void perf_hpp_list__prepend_sort_field(struct perf_hpp_list *list, |
596 | struct perf_hpp_fmt *format) | |
597 | { | |
598 | list_add(&format->sort_list, &list->sorts); | |
599 | } | |
600 | ||
ebdd98e0 | 601 | void perf_hpp__column_unregister(struct perf_hpp_fmt *format) |
8b536999 | 602 | { |
70b01dfd | 603 | list_del_init(&format->list); |
8b536999 NK |
604 | } |
605 | ||
77284de3 NK |
606 | void perf_hpp__cancel_cumulate(void) |
607 | { | |
1945c3e7 JO |
608 | struct perf_hpp_fmt *fmt, *acc, *ovh, *tmp; |
609 | ||
2f3f9bcf | 610 | if (is_strict_order(field_order)) |
2bf1a123 NK |
611 | return; |
612 | ||
1945c3e7 JO |
613 | ovh = &perf_hpp__format[PERF_HPP__OVERHEAD]; |
614 | acc = &perf_hpp__format[PERF_HPP__OVERHEAD_ACC]; | |
615 | ||
7a1799e0 | 616 | perf_hpp_list__for_each_format_safe(&perf_hpp_list, fmt, tmp) { |
1945c3e7 JO |
617 | if (acc->equal(acc, fmt)) { |
618 | perf_hpp__column_unregister(fmt); | |
619 | continue; | |
620 | } | |
621 | ||
622 | if (ovh->equal(ovh, fmt)) | |
623 | fmt->name = "Overhead"; | |
624 | } | |
77284de3 NK |
625 | } |
626 | ||
97358084 JO |
627 | static bool fmt_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b) |
628 | { | |
629 | return a->equal && a->equal(a, b); | |
630 | } | |
631 | ||
43e0a68f | 632 | void perf_hpp__setup_output_field(struct perf_hpp_list *list) |
26d8b338 NK |
633 | { |
634 | struct perf_hpp_fmt *fmt; | |
635 | ||
636 | /* append sort keys to output field */ | |
43e0a68f | 637 | perf_hpp_list__for_each_sort_list(list, fmt) { |
3f931f2c | 638 | struct perf_hpp_fmt *pos; |
a7d945bc | 639 | |
8381cdd0 NK |
640 | /* skip sort-only fields ("sort_compute" in perf diff) */ |
641 | if (!fmt->entry && !fmt->color) | |
642 | continue; | |
643 | ||
43e0a68f | 644 | perf_hpp_list__for_each_format(list, pos) { |
3f931f2c JO |
645 | if (fmt_equal(fmt, pos)) |
646 | goto next; | |
a7d945bc NK |
647 | } |
648 | ||
649 | perf_hpp__column_register(fmt); | |
650 | next: | |
651 | continue; | |
652 | } | |
653 | } | |
654 | ||
43e0a68f | 655 | void perf_hpp__append_sort_keys(struct perf_hpp_list *list) |
a7d945bc NK |
656 | { |
657 | struct perf_hpp_fmt *fmt; | |
658 | ||
659 | /* append output fields to sort keys */ | |
43e0a68f | 660 | perf_hpp_list__for_each_format(list, fmt) { |
3f931f2c | 661 | struct perf_hpp_fmt *pos; |
a7d945bc | 662 | |
43e0a68f | 663 | perf_hpp_list__for_each_sort_list(list, pos) { |
3f931f2c JO |
664 | if (fmt_equal(fmt, pos)) |
665 | goto next; | |
a7d945bc NK |
666 | } |
667 | ||
668 | perf_hpp__register_sort_field(fmt); | |
669 | next: | |
670 | continue; | |
26d8b338 NK |
671 | } |
672 | } | |
673 | ||
43e0a68f | 674 | |
564132f3 JO |
675 | static void fmt_free(struct perf_hpp_fmt *fmt) |
676 | { | |
d0e35234 JO |
677 | /* |
678 | * At this point fmt should be completely | |
679 | * unhooked, if not it's a bug. | |
680 | */ | |
681 | BUG_ON(!list_empty(&fmt->list)); | |
682 | BUG_ON(!list_empty(&fmt->sort_list)); | |
683 | ||
564132f3 JO |
684 | if (fmt->free) |
685 | fmt->free(fmt); | |
686 | } | |
687 | ||
43e0a68f | 688 | void perf_hpp__reset_output_field(struct perf_hpp_list *list) |
1c89fe9b NK |
689 | { |
690 | struct perf_hpp_fmt *fmt, *tmp; | |
691 | ||
692 | /* reset output fields */ | |
43e0a68f | 693 | perf_hpp_list__for_each_format_safe(list, fmt, tmp) { |
1c89fe9b NK |
694 | list_del_init(&fmt->list); |
695 | list_del_init(&fmt->sort_list); | |
564132f3 | 696 | fmt_free(fmt); |
1c89fe9b NK |
697 | } |
698 | ||
699 | /* reset sort keys */ | |
43e0a68f | 700 | perf_hpp_list__for_each_sort_list_safe(list, fmt, tmp) { |
1c89fe9b NK |
701 | list_del_init(&fmt->list); |
702 | list_del_init(&fmt->sort_list); | |
564132f3 | 703 | fmt_free(fmt); |
1c89fe9b NK |
704 | } |
705 | } | |
706 | ||
7e62ef44 NK |
707 | /* |
708 | * See hists__fprintf to match the column widths | |
709 | */ | |
710 | unsigned int hists__sort_list_width(struct hists *hists) | |
711 | { | |
1240005e | 712 | struct perf_hpp_fmt *fmt; |
cfaa154b NK |
713 | int ret = 0; |
714 | bool first = true; | |
94a0793d | 715 | struct perf_hpp dummy_hpp; |
7e62ef44 | 716 | |
f0786af5 | 717 | hists__for_each_format(hists, fmt) { |
361459f1 | 718 | if (perf_hpp__should_skip(fmt, hists)) |
cfaa154b NK |
719 | continue; |
720 | ||
721 | if (first) | |
722 | first = false; | |
723 | else | |
7e62ef44 NK |
724 | ret += 2; |
725 | ||
da1b0407 | 726 | ret += fmt->width(fmt, &dummy_hpp, hists); |
7e62ef44 NK |
727 | } |
728 | ||
bb963e16 | 729 | if (verbose > 0 && hists__has(hists, sym)) /* Addr + origin */ |
7e62ef44 NK |
730 | ret += 3 + BITS_PER_LONG / 4; |
731 | ||
732 | return ret; | |
733 | } | |
e0d66c74 | 734 | |
a7b5895b NK |
735 | unsigned int hists__overhead_width(struct hists *hists) |
736 | { | |
737 | struct perf_hpp_fmt *fmt; | |
738 | int ret = 0; | |
739 | bool first = true; | |
740 | struct perf_hpp dummy_hpp; | |
741 | ||
742 | hists__for_each_format(hists, fmt) { | |
743 | if (perf_hpp__is_sort_entry(fmt) || perf_hpp__is_dynamic_entry(fmt)) | |
744 | break; | |
745 | ||
746 | if (first) | |
747 | first = false; | |
748 | else | |
749 | ret += 2; | |
750 | ||
da1b0407 | 751 | ret += fmt->width(fmt, &dummy_hpp, hists); |
a7b5895b NK |
752 | } |
753 | ||
754 | return ret; | |
755 | } | |
756 | ||
e0d66c74 NK |
757 | void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists) |
758 | { | |
e0d66c74 NK |
759 | if (perf_hpp__is_sort_entry(fmt)) |
760 | return perf_hpp__reset_sort_width(fmt, hists); | |
761 | ||
dd42baf1 NK |
762 | if (perf_hpp__is_dynamic_entry(fmt)) |
763 | return; | |
764 | ||
2e8b79e7 | 765 | BUG_ON(fmt->idx >= PERF_HPP__MAX_INDEX); |
e0d66c74 | 766 | |
2e8b79e7 | 767 | switch (fmt->idx) { |
e0d66c74 NK |
768 | case PERF_HPP__OVERHEAD: |
769 | case PERF_HPP__OVERHEAD_SYS: | |
770 | case PERF_HPP__OVERHEAD_US: | |
771 | case PERF_HPP__OVERHEAD_ACC: | |
772 | fmt->len = 8; | |
773 | break; | |
774 | ||
775 | case PERF_HPP__OVERHEAD_GUEST_SYS: | |
776 | case PERF_HPP__OVERHEAD_GUEST_US: | |
777 | fmt->len = 9; | |
778 | break; | |
779 | ||
780 | case PERF_HPP__SAMPLES: | |
781 | case PERF_HPP__PERIOD: | |
782 | fmt->len = 12; | |
783 | break; | |
784 | ||
785 | default: | |
786 | break; | |
787 | } | |
788 | } | |
5b591669 | 789 | |
e3b60bc9 NK |
790 | void hists__reset_column_width(struct hists *hists) |
791 | { | |
792 | struct perf_hpp_fmt *fmt; | |
793 | struct perf_hpp_list_node *node; | |
794 | ||
795 | hists__for_each_format(hists, fmt) | |
796 | perf_hpp__reset_width(fmt, hists); | |
797 | ||
798 | /* hierarchy entries have their own hpp list */ | |
799 | list_for_each_entry(node, &hists->hpp_formats, list) { | |
800 | perf_hpp_list__for_each_format(&node->hpp, fmt) | |
801 | perf_hpp__reset_width(fmt, hists); | |
802 | } | |
803 | } | |
804 | ||
5b591669 NK |
805 | void perf_hpp__set_user_width(const char *width_list_str) |
806 | { | |
807 | struct perf_hpp_fmt *fmt; | |
808 | const char *ptr = width_list_str; | |
809 | ||
cf094045 | 810 | perf_hpp_list__for_each_format(&perf_hpp_list, fmt) { |
5b591669 NK |
811 | char *p; |
812 | ||
813 | int len = strtol(ptr, &p, 10); | |
814 | fmt->user_len = len; | |
815 | ||
816 | if (*p == ',') | |
817 | ptr = p + 1; | |
818 | else | |
819 | break; | |
820 | } | |
821 | } | |
c3bc0c43 NK |
822 | |
823 | static int add_hierarchy_fmt(struct hists *hists, struct perf_hpp_fmt *fmt) | |
824 | { | |
825 | struct perf_hpp_list_node *node = NULL; | |
826 | struct perf_hpp_fmt *fmt_copy; | |
827 | bool found = false; | |
1b2dbbf4 | 828 | bool skip = perf_hpp__should_skip(fmt, hists); |
c3bc0c43 NK |
829 | |
830 | list_for_each_entry(node, &hists->hpp_formats, list) { | |
831 | if (node->level == fmt->level) { | |
832 | found = true; | |
833 | break; | |
834 | } | |
835 | } | |
836 | ||
837 | if (!found) { | |
838 | node = malloc(sizeof(*node)); | |
839 | if (node == NULL) | |
840 | return -1; | |
841 | ||
1b2dbbf4 | 842 | node->skip = skip; |
c3bc0c43 NK |
843 | node->level = fmt->level; |
844 | perf_hpp_list__init(&node->hpp); | |
845 | ||
2dbbe9f2 | 846 | hists->nr_hpp_node++; |
c3bc0c43 NK |
847 | list_add_tail(&node->list, &hists->hpp_formats); |
848 | } | |
849 | ||
850 | fmt_copy = perf_hpp_fmt__dup(fmt); | |
851 | if (fmt_copy == NULL) | |
852 | return -1; | |
853 | ||
1b2dbbf4 NK |
854 | if (!skip) |
855 | node->skip = false; | |
856 | ||
c3bc0c43 NK |
857 | list_add_tail(&fmt_copy->list, &node->hpp.fields); |
858 | list_add_tail(&fmt_copy->sort_list, &node->hpp.sorts); | |
859 | ||
860 | return 0; | |
861 | } | |
862 | ||
863 | int perf_hpp__setup_hists_formats(struct perf_hpp_list *list, | |
63503dba | 864 | struct evlist *evlist) |
c3bc0c43 | 865 | { |
32dcd021 | 866 | struct evsel *evsel; |
c3bc0c43 NK |
867 | struct perf_hpp_fmt *fmt; |
868 | struct hists *hists; | |
869 | int ret; | |
870 | ||
871 | if (!symbol_conf.report_hierarchy) | |
872 | return 0; | |
873 | ||
e5cadb93 | 874 | evlist__for_each_entry(evlist, evsel) { |
c3bc0c43 NK |
875 | hists = evsel__hists(evsel); |
876 | ||
877 | perf_hpp_list__for_each_sort_list(list, fmt) { | |
878 | if (perf_hpp__is_dynamic_entry(fmt) && | |
879 | !perf_hpp__defined_dynamic_entry(fmt, hists)) | |
880 | continue; | |
881 | ||
882 | ret = add_hierarchy_fmt(hists, fmt); | |
883 | if (ret < 0) | |
884 | return ret; | |
885 | } | |
886 | } | |
887 | ||
888 | return 0; | |
889 | } |