Commit | Line | Data |
---|---|---|
ea251d51 NK |
1 | #include <math.h> |
2 | ||
3 | #include "../util/hist.h" | |
4 | #include "../util/util.h" | |
5 | #include "../util/sort.h" | |
4fb71074 | 6 | #include "../util/evsel.h" |
ea251d51 NK |
7 | |
8 | /* hist period print (hpp) functions */ | |
ea251d51 | 9 | |
4fb71074 | 10 | typedef int (*hpp_snprint_fn)(char *buf, size_t size, const char *fmt, ...); |
ea251d51 | 11 | |
0c5268bf JO |
12 | static int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he, |
13 | u64 (*get_field)(struct hist_entry *), | |
14 | const char *fmt, hpp_snprint_fn print_fn, | |
15 | bool fmt_percent) | |
ea251d51 | 16 | { |
4fb71074 | 17 | int ret; |
b5ff71c3 | 18 | struct hists *hists = he->hists; |
759ff497 | 19 | struct perf_evsel *evsel = hists_to_evsel(hists); |
ea251d51 | 20 | |
0c5268bf JO |
21 | if (fmt_percent) { |
22 | double percent = 0.0; | |
9ffad987 | 23 | |
0c5268bf JO |
24 | if (hists->stats.total_period) |
25 | percent = 100.0 * get_field(he) / | |
26 | hists->stats.total_period; | |
27 | ||
28 | ret = print_fn(hpp->buf, hpp->size, fmt, percent); | |
29 | } else | |
30 | ret = print_fn(hpp->buf, hpp->size, fmt, get_field(he)); | |
5b9e2146 | 31 | |
759ff497 | 32 | if (perf_evsel__is_group_event(evsel)) { |
5b9e2146 | 33 | int prev_idx, idx_delta; |
5b9e2146 NK |
34 | struct hist_entry *pair; |
35 | int nr_members = evsel->nr_members; | |
36 | ||
5b9e2146 NK |
37 | prev_idx = perf_evsel__group_idx(evsel); |
38 | ||
39 | list_for_each_entry(pair, &he->pairs.head, pairs.node) { | |
40 | u64 period = get_field(pair); | |
41 | u64 total = pair->hists->stats.total_period; | |
42 | ||
43 | if (!total) | |
44 | continue; | |
45 | ||
46 | evsel = hists_to_evsel(pair->hists); | |
47 | idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1; | |
48 | ||
49 | while (idx_delta--) { | |
50 | /* | |
51 | * zero-fill group members in the middle which | |
52 | * have no sample | |
53 | */ | |
54 | ret += print_fn(hpp->buf + ret, hpp->size - ret, | |
0c5268bf | 55 | fmt, 0); |
5b9e2146 NK |
56 | } |
57 | ||
0c5268bf JO |
58 | if (fmt_percent) |
59 | ret += print_fn(hpp->buf + ret, hpp->size - ret, | |
60 | fmt, 100.0 * period / total); | |
61 | else | |
62 | ret += print_fn(hpp->buf + ret, hpp->size - ret, | |
63 | fmt, period); | |
5b9e2146 NK |
64 | |
65 | prev_idx = perf_evsel__group_idx(evsel); | |
66 | } | |
67 | ||
68 | idx_delta = nr_members - prev_idx - 1; | |
69 | ||
70 | while (idx_delta--) { | |
71 | /* | |
72 | * zero-fill group members at last which have no sample | |
73 | */ | |
74 | ret += print_fn(hpp->buf + ret, hpp->size - ret, | |
0c5268bf | 75 | fmt, 0); |
5b9e2146 NK |
76 | } |
77 | } | |
4fb71074 | 78 | return ret; |
ea251d51 NK |
79 | } |
80 | ||
4fb71074 NK |
81 | #define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ |
82 | static int hpp__header_##_type(struct perf_hpp *hpp) \ | |
83 | { \ | |
84 | int len = _min_width; \ | |
85 | \ | |
5b9e2146 NK |
86 | if (symbol_conf.event_group) { \ |
87 | struct perf_evsel *evsel = hpp->ptr; \ | |
88 | \ | |
89 | len = max(len, evsel->nr_members * _unit_width); \ | |
90 | } \ | |
4fb71074 | 91 | return scnprintf(hpp->buf, hpp->size, "%*s", len, _str); \ |
ea251d51 NK |
92 | } |
93 | ||
4fb71074 NK |
94 | #define __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ |
95 | static int hpp__width_##_type(struct perf_hpp *hpp __maybe_unused) \ | |
96 | { \ | |
97 | int len = _min_width; \ | |
98 | \ | |
5b9e2146 NK |
99 | if (symbol_conf.event_group) { \ |
100 | struct perf_evsel *evsel = hpp->ptr; \ | |
101 | \ | |
102 | len = max(len, evsel->nr_members * _unit_width); \ | |
103 | } \ | |
4fb71074 | 104 | return len; \ |
ea251d51 NK |
105 | } |
106 | ||
4fb71074 NK |
107 | #define __HPP_COLOR_PERCENT_FN(_type, _field) \ |
108 | static u64 he_get_##_field(struct hist_entry *he) \ | |
109 | { \ | |
110 | return he->stat._field; \ | |
111 | } \ | |
112 | \ | |
113 | static int hpp__color_##_type(struct perf_hpp *hpp, struct hist_entry *he) \ | |
114 | { \ | |
0c5268bf JO |
115 | return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%", \ |
116 | (hpp_snprint_fn)percent_color_snprintf, true); \ | |
ea251d51 NK |
117 | } |
118 | ||
4fb71074 NK |
119 | #define __HPP_ENTRY_PERCENT_FN(_type, _field) \ |
120 | static int hpp__entry_##_type(struct perf_hpp *hpp, struct hist_entry *he) \ | |
121 | { \ | |
122 | const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%"; \ | |
0c5268bf JO |
123 | return __hpp__fmt(hpp, he, he_get_##_field, fmt, \ |
124 | scnprintf, true); \ | |
ea251d51 NK |
125 | } |
126 | ||
4fb71074 NK |
127 | #define __HPP_ENTRY_RAW_FN(_type, _field) \ |
128 | static u64 he_get_raw_##_field(struct hist_entry *he) \ | |
129 | { \ | |
130 | return he->stat._field; \ | |
131 | } \ | |
132 | \ | |
133 | static int hpp__entry_##_type(struct perf_hpp *hpp, struct hist_entry *he) \ | |
134 | { \ | |
135 | const char *fmt = symbol_conf.field_sep ? " %"PRIu64 : " %11"PRIu64; \ | |
0c5268bf | 136 | return __hpp__fmt(hpp, he, he_get_raw_##_field, fmt, scnprintf, false); \ |
ea251d51 NK |
137 | } |
138 | ||
4fb71074 NK |
139 | #define HPP_PERCENT_FNS(_type, _str, _field, _min_width, _unit_width) \ |
140 | __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ | |
141 | __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ | |
142 | __HPP_COLOR_PERCENT_FN(_type, _field) \ | |
143 | __HPP_ENTRY_PERCENT_FN(_type, _field) | |
ea251d51 | 144 | |
4fb71074 NK |
145 | #define HPP_RAW_FNS(_type, _str, _field, _min_width, _unit_width) \ |
146 | __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ | |
147 | __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ | |
148 | __HPP_ENTRY_RAW_FN(_type, _field) | |
ea251d51 | 149 | |
b5ff71c3 | 150 | |
4fb71074 NK |
151 | HPP_PERCENT_FNS(overhead, "Overhead", period, 8, 8) |
152 | HPP_PERCENT_FNS(overhead_sys, "sys", period_sys, 8, 8) | |
153 | HPP_PERCENT_FNS(overhead_us, "usr", period_us, 8, 8) | |
154 | HPP_PERCENT_FNS(overhead_guest_sys, "guest sys", period_guest_sys, 9, 8) | |
155 | HPP_PERCENT_FNS(overhead_guest_us, "guest usr", period_guest_us, 9, 8) | |
ea251d51 | 156 | |
4fb71074 NK |
157 | HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12) |
158 | HPP_RAW_FNS(period, "Period", period, 12, 12) | |
9ffad987 | 159 | |
ea251d51 | 160 | |
5395a048 JO |
161 | static int hpp__header_baseline(struct perf_hpp *hpp) |
162 | { | |
163 | return scnprintf(hpp->buf, hpp->size, "Baseline"); | |
164 | } | |
165 | ||
166 | static int hpp__width_baseline(struct perf_hpp *hpp __maybe_unused) | |
167 | { | |
168 | return 8; | |
169 | } | |
170 | ||
171 | static double baseline_percent(struct hist_entry *he) | |
172 | { | |
b821c732 | 173 | struct hist_entry *pair = hist_entry__next_pair(he); |
5395a048 JO |
174 | struct hists *pair_hists = pair ? pair->hists : NULL; |
175 | double percent = 0.0; | |
176 | ||
177 | if (pair) { | |
178 | u64 total_period = pair_hists->stats.total_period; | |
b24c28f7 | 179 | u64 base_period = pair->stat.period; |
5395a048 JO |
180 | |
181 | percent = 100.0 * base_period / total_period; | |
182 | } | |
183 | ||
184 | return percent; | |
185 | } | |
186 | ||
187 | static int hpp__color_baseline(struct perf_hpp *hpp, struct hist_entry *he) | |
188 | { | |
189 | double percent = baseline_percent(he); | |
190 | ||
4fb71074 | 191 | if (hist_entry__has_pairs(he) || symbol_conf.field_sep) |
6e92349d JO |
192 | return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%%", percent); |
193 | else | |
194 | return scnprintf(hpp->buf, hpp->size, " "); | |
5395a048 JO |
195 | } |
196 | ||
197 | static int hpp__entry_baseline(struct perf_hpp *hpp, struct hist_entry *he) | |
198 | { | |
199 | double percent = baseline_percent(he); | |
200 | const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%%"; | |
201 | ||
b821c732 | 202 | if (hist_entry__has_pairs(he) || symbol_conf.field_sep) |
6e92349d JO |
203 | return scnprintf(hpp->buf, hpp->size, fmt, percent); |
204 | else | |
205 | return scnprintf(hpp->buf, hpp->size, " "); | |
5395a048 JO |
206 | } |
207 | ||
61949b21 JO |
208 | static int hpp__header_period_baseline(struct perf_hpp *hpp) |
209 | { | |
210 | const char *fmt = symbol_conf.field_sep ? "%s" : "%12s"; | |
211 | ||
212 | return scnprintf(hpp->buf, hpp->size, fmt, "Period Base"); | |
213 | } | |
214 | ||
215 | static int hpp__width_period_baseline(struct perf_hpp *hpp __maybe_unused) | |
216 | { | |
217 | return 12; | |
218 | } | |
219 | ||
220 | static int hpp__entry_period_baseline(struct perf_hpp *hpp, struct hist_entry *he) | |
221 | { | |
b821c732 | 222 | struct hist_entry *pair = hist_entry__next_pair(he); |
61949b21 JO |
223 | u64 period = pair ? pair->stat.period : 0; |
224 | const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%12" PRIu64; | |
225 | ||
226 | return scnprintf(hpp->buf, hpp->size, fmt, period); | |
227 | } | |
4fb71074 | 228 | |
ea251d51 NK |
229 | static int hpp__header_delta(struct perf_hpp *hpp) |
230 | { | |
9ffad987 NK |
231 | const char *fmt = symbol_conf.field_sep ? "%s" : "%7s"; |
232 | ||
233 | return scnprintf(hpp->buf, hpp->size, fmt, "Delta"); | |
ea251d51 NK |
234 | } |
235 | ||
1d037ca1 | 236 | static int hpp__width_delta(struct perf_hpp *hpp __maybe_unused) |
ea251d51 NK |
237 | { |
238 | return 7; | |
239 | } | |
240 | ||
241 | static int hpp__entry_delta(struct perf_hpp *hpp, struct hist_entry *he) | |
242 | { | |
05472daa | 243 | struct hist_entry *pair = hist_entry__next_pair(he); |
9ffad987 NK |
244 | const char *fmt = symbol_conf.field_sep ? "%s" : "%7.7s"; |
245 | char buf[32] = " "; | |
05472daa | 246 | double diff = 0.0; |
ea251d51 | 247 | |
05472daa JO |
248 | if (pair) { |
249 | if (he->diff.computed) | |
250 | diff = he->diff.period_ratio_delta; | |
251 | else | |
252 | diff = perf_diff__compute_delta(he, pair); | |
253 | } else | |
254 | diff = perf_diff__period_percent(he, he->stat.period); | |
ea251d51 | 255 | |
9ffad987 NK |
256 | if (fabs(diff) >= 0.01) |
257 | scnprintf(buf, sizeof(buf), "%+4.2F%%", diff); | |
ea251d51 | 258 | |
9ffad987 | 259 | return scnprintf(hpp->buf, hpp->size, fmt, buf); |
ea251d51 NK |
260 | } |
261 | ||
7aaf6b35 JO |
262 | static int hpp__header_ratio(struct perf_hpp *hpp) |
263 | { | |
264 | const char *fmt = symbol_conf.field_sep ? "%s" : "%14s"; | |
265 | ||
266 | return scnprintf(hpp->buf, hpp->size, fmt, "Ratio"); | |
267 | } | |
268 | ||
269 | static int hpp__width_ratio(struct perf_hpp *hpp __maybe_unused) | |
270 | { | |
271 | return 14; | |
272 | } | |
273 | ||
274 | static int hpp__entry_ratio(struct perf_hpp *hpp, struct hist_entry *he) | |
275 | { | |
05472daa | 276 | struct hist_entry *pair = hist_entry__next_pair(he); |
7aaf6b35 JO |
277 | const char *fmt = symbol_conf.field_sep ? "%s" : "%14s"; |
278 | char buf[32] = " "; | |
05472daa | 279 | double ratio = 0.0; |
96c47f19 | 280 | |
05472daa JO |
281 | if (pair) { |
282 | if (he->diff.computed) | |
283 | ratio = he->diff.period_ratio; | |
284 | else | |
285 | ratio = perf_diff__compute_ratio(he, pair); | |
286 | } | |
7aaf6b35 JO |
287 | |
288 | if (ratio > 0.0) | |
289 | scnprintf(buf, sizeof(buf), "%+14.6F", ratio); | |
290 | ||
291 | return scnprintf(hpp->buf, hpp->size, fmt, buf); | |
292 | } | |
293 | ||
81d5f958 JO |
294 | static int hpp__header_wdiff(struct perf_hpp *hpp) |
295 | { | |
296 | const char *fmt = symbol_conf.field_sep ? "%s" : "%14s"; | |
297 | ||
298 | return scnprintf(hpp->buf, hpp->size, fmt, "Weighted diff"); | |
299 | } | |
300 | ||
301 | static int hpp__width_wdiff(struct perf_hpp *hpp __maybe_unused) | |
302 | { | |
303 | return 14; | |
304 | } | |
305 | ||
306 | static int hpp__entry_wdiff(struct perf_hpp *hpp, struct hist_entry *he) | |
307 | { | |
05472daa | 308 | struct hist_entry *pair = hist_entry__next_pair(he); |
81d5f958 JO |
309 | const char *fmt = symbol_conf.field_sep ? "%s" : "%14s"; |
310 | char buf[32] = " "; | |
05472daa | 311 | s64 wdiff = 0; |
81d5f958 | 312 | |
05472daa JO |
313 | if (pair) { |
314 | if (he->diff.computed) | |
315 | wdiff = he->diff.wdiff; | |
316 | else | |
317 | wdiff = perf_diff__compute_wdiff(he, pair); | |
318 | } | |
81d5f958 JO |
319 | |
320 | if (wdiff != 0) | |
321 | scnprintf(buf, sizeof(buf), "%14ld", wdiff); | |
322 | ||
323 | return scnprintf(hpp->buf, hpp->size, fmt, buf); | |
324 | } | |
325 | ||
ed279da2 JO |
326 | static int hpp__header_formula(struct perf_hpp *hpp) |
327 | { | |
328 | const char *fmt = symbol_conf.field_sep ? "%s" : "%70s"; | |
329 | ||
330 | return scnprintf(hpp->buf, hpp->size, fmt, "Formula"); | |
331 | } | |
332 | ||
333 | static int hpp__width_formula(struct perf_hpp *hpp __maybe_unused) | |
334 | { | |
335 | return 70; | |
336 | } | |
337 | ||
338 | static int hpp__entry_formula(struct perf_hpp *hpp, struct hist_entry *he) | |
339 | { | |
f4c8bae1 | 340 | struct hist_entry *pair = hist_entry__next_pair(he); |
ed279da2 JO |
341 | const char *fmt = symbol_conf.field_sep ? "%s" : "%-70s"; |
342 | char buf[96] = " "; | |
343 | ||
f4c8bae1 JO |
344 | if (pair) |
345 | perf_diff__formula(he, pair, buf, sizeof(buf)); | |
346 | ||
ed279da2 JO |
347 | return scnprintf(hpp->buf, hpp->size, fmt, buf); |
348 | } | |
349 | ||
1240005e JO |
350 | #define HPP__COLOR_PRINT_FNS(_name) \ |
351 | { \ | |
352 | .header = hpp__header_ ## _name, \ | |
353 | .width = hpp__width_ ## _name, \ | |
354 | .color = hpp__color_ ## _name, \ | |
355 | .entry = hpp__entry_ ## _name \ | |
356 | } | |
ea251d51 | 357 | |
1240005e JO |
358 | #define HPP__PRINT_FNS(_name) \ |
359 | { \ | |
360 | .header = hpp__header_ ## _name, \ | |
361 | .width = hpp__width_ ## _name, \ | |
362 | .entry = hpp__entry_ ## _name \ | |
363 | } | |
ea251d51 NK |
364 | |
365 | struct perf_hpp_fmt perf_hpp__format[] = { | |
1240005e JO |
366 | HPP__COLOR_PRINT_FNS(baseline), |
367 | HPP__COLOR_PRINT_FNS(overhead), | |
368 | HPP__COLOR_PRINT_FNS(overhead_sys), | |
369 | HPP__COLOR_PRINT_FNS(overhead_us), | |
370 | HPP__COLOR_PRINT_FNS(overhead_guest_sys), | |
371 | HPP__COLOR_PRINT_FNS(overhead_guest_us), | |
372 | HPP__PRINT_FNS(samples), | |
373 | HPP__PRINT_FNS(period), | |
374 | HPP__PRINT_FNS(period_baseline), | |
375 | HPP__PRINT_FNS(delta), | |
376 | HPP__PRINT_FNS(ratio), | |
377 | HPP__PRINT_FNS(wdiff), | |
1240005e | 378 | HPP__PRINT_FNS(formula) |
ea251d51 NK |
379 | }; |
380 | ||
1240005e JO |
381 | LIST_HEAD(perf_hpp__list); |
382 | ||
4fb71074 | 383 | |
ea251d51 NK |
384 | #undef HPP__COLOR_PRINT_FNS |
385 | #undef HPP__PRINT_FNS | |
386 | ||
4fb71074 NK |
387 | #undef HPP_PERCENT_FNS |
388 | #undef HPP_RAW_FNS | |
389 | ||
390 | #undef __HPP_HEADER_FN | |
391 | #undef __HPP_WIDTH_FN | |
392 | #undef __HPP_COLOR_PERCENT_FN | |
393 | #undef __HPP_ENTRY_PERCENT_FN | |
394 | #undef __HPP_ENTRY_RAW_FN | |
395 | ||
396 | ||
1d77822e | 397 | void perf_hpp__init(void) |
ea251d51 NK |
398 | { |
399 | if (symbol_conf.show_cpu_utilization) { | |
1240005e JO |
400 | perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS); |
401 | perf_hpp__column_enable(PERF_HPP__OVERHEAD_US); | |
ea251d51 NK |
402 | |
403 | if (perf_guest) { | |
1240005e JO |
404 | perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS); |
405 | perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US); | |
ea251d51 NK |
406 | } |
407 | } | |
408 | ||
409 | if (symbol_conf.show_nr_samples) | |
1240005e | 410 | perf_hpp__column_enable(PERF_HPP__SAMPLES); |
ea251d51 NK |
411 | |
412 | if (symbol_conf.show_total_period) | |
1240005e | 413 | perf_hpp__column_enable(PERF_HPP__PERIOD); |
1d77822e | 414 | } |
ea251d51 | 415 | |
1240005e JO |
416 | void perf_hpp__column_register(struct perf_hpp_fmt *format) |
417 | { | |
418 | list_add_tail(&format->list, &perf_hpp__list); | |
419 | } | |
420 | ||
421 | void perf_hpp__column_enable(unsigned col) | |
1d77822e JO |
422 | { |
423 | BUG_ON(col >= PERF_HPP__MAX_INDEX); | |
1240005e | 424 | perf_hpp__column_register(&perf_hpp__format[col]); |
ea251d51 NK |
425 | } |
426 | ||
427 | static inline void advance_hpp(struct perf_hpp *hpp, int inc) | |
428 | { | |
429 | hpp->buf += inc; | |
430 | hpp->size -= inc; | |
431 | } | |
432 | ||
433 | int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he, | |
434 | bool color) | |
435 | { | |
436 | const char *sep = symbol_conf.field_sep; | |
1240005e | 437 | struct perf_hpp_fmt *fmt; |
ea251d51 | 438 | char *start = hpp->buf; |
1240005e | 439 | int ret; |
5395a048 | 440 | bool first = true; |
ea251d51 NK |
441 | |
442 | if (symbol_conf.exclude_other && !he->parent) | |
443 | return 0; | |
444 | ||
1240005e | 445 | perf_hpp__for_each_format(fmt) { |
c0d246b8 JO |
446 | /* |
447 | * If there's no field_sep, we still need | |
448 | * to display initial ' '. | |
449 | */ | |
5395a048 | 450 | if (!sep || !first) { |
ea251d51 NK |
451 | ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: " "); |
452 | advance_hpp(hpp, ret); | |
c0d246b8 | 453 | } else |
5395a048 | 454 | first = false; |
ea251d51 | 455 | |
1240005e JO |
456 | if (color && fmt->color) |
457 | ret = fmt->color(hpp, he); | |
ea251d51 | 458 | else |
1240005e | 459 | ret = fmt->entry(hpp, he); |
ea251d51 NK |
460 | |
461 | advance_hpp(hpp, ret); | |
462 | } | |
463 | ||
464 | return hpp->buf - start; | |
465 | } | |
466 | ||
467 | int hist_entry__sort_snprintf(struct hist_entry *he, char *s, size_t size, | |
468 | struct hists *hists) | |
469 | { | |
470 | const char *sep = symbol_conf.field_sep; | |
471 | struct sort_entry *se; | |
472 | int ret = 0; | |
473 | ||
474 | list_for_each_entry(se, &hist_entry__sort_list, list) { | |
475 | if (se->elide) | |
476 | continue; | |
477 | ||
478 | ret += scnprintf(s + ret, size - ret, "%s", sep ?: " "); | |
479 | ret += se->se_snprintf(he, s + ret, size - ret, | |
480 | hists__col_len(hists, se->se_width_idx)); | |
481 | } | |
482 | ||
483 | return ret; | |
484 | } | |
7e62ef44 NK |
485 | |
486 | /* | |
487 | * See hists__fprintf to match the column widths | |
488 | */ | |
489 | unsigned int hists__sort_list_width(struct hists *hists) | |
490 | { | |
1240005e | 491 | struct perf_hpp_fmt *fmt; |
7e62ef44 | 492 | struct sort_entry *se; |
1240005e | 493 | int i = 0, ret = 0; |
5b9e2146 NK |
494 | struct perf_hpp dummy_hpp = { |
495 | .ptr = hists_to_evsel(hists), | |
496 | }; | |
7e62ef44 | 497 | |
1240005e | 498 | perf_hpp__for_each_format(fmt) { |
7e62ef44 NK |
499 | if (i) |
500 | ret += 2; | |
501 | ||
5b9e2146 | 502 | ret += fmt->width(&dummy_hpp); |
7e62ef44 NK |
503 | } |
504 | ||
505 | list_for_each_entry(se, &hist_entry__sort_list, list) | |
506 | if (!se->elide) | |
507 | ret += 2 + hists__col_len(hists, se->se_width_idx); | |
508 | ||
509 | if (verbose) /* Addr + origin */ | |
510 | ret += 3 + BITS_PER_LONG / 4; | |
511 | ||
512 | return ret; | |
513 | } |