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