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