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