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