tools/perf/ui/hist.c

   1 #include <math.h>
   2 #include <linux/compiler.h>
   3
   4 #include "../util/hist.h"
   5 #include "../util/util.h"
   6 #include "../util/sort.h"
   7 #include "../util/evsel.h"
   8
   9 /* hist period print (hpp) functions */
  10
  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
  18 int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
  19                hpp_field_fn get_field, const char *fmt,
  20                hpp_snprint_fn print_fn, bool fmt_percent)
  21 {
  22         int ret;
  23         struct hists *hists = he->hists;
  24         struct perf_evsel *evsel = hists_to_evsel(hists);
  25         char *buf = hpp->buf;
  26         size_t size = hpp->size;
  27
  28         if (fmt_percent) {
  29                 double percent = 0.0;
  30                 u64 total = hists__total_period(hists);
  31
  32                 if (total)
  33                         percent = 100.0 * get_field(he) / total;
  34
  35                 ret = hpp__call_print_fn(hpp, print_fn, fmt, percent);
  36         } else
  37                 ret = hpp__call_print_fn(hpp, print_fn, fmt, get_field(he));
  38
  39         if (perf_evsel__is_group_event(evsel)) {
  40                 int prev_idx, idx_delta;
  41                 struct hist_entry *pair;
  42                 int nr_members = evsel->nr_members;
  43
  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);
  48                         u64 total = hists__total_period(pair->hists);
  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                                  */
  61                                 if (fmt_percent) {
  62                                         ret += hpp__call_print_fn(hpp, print_fn,
  63                                                                   fmt, 0.0);
  64                                 } else {
  65                                         ret += hpp__call_print_fn(hpp, print_fn,
  66                                                                   fmt, 0ULL);
  67                                 }
  68                         }
  69
  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                         }
  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                          */
  87                         if (fmt_percent) {
  88                                 ret += hpp__call_print_fn(hpp, print_fn,
  89                                                           fmt, 0.0);
  90                         } else {
  91                                 ret += hpp__call_print_fn(hpp, print_fn,
  92                                                           fmt, 0ULL);
  93                         }
  94                 }
  95         }
  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
 104         return ret;
 105 }
 106
 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
 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
 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
 193 #define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width)           \
 194 static int hpp__header_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
 195                                struct perf_hpp *hpp,                    \
 196                                struct perf_evsel *evsel)                \
 197 {                                                                       \
 198         int len = _min_width;                                           \
 199                                                                         \
 200         if (symbol_conf.event_group)                                    \
 201                 len = max(len, evsel->nr_members * _unit_width);        \
 202                                                                         \
 203         return scnprintf(hpp->buf, hpp->size, "%*s", len, _str);        \
 204 }
 205
 206 #define __HPP_WIDTH_FN(_type, _min_width, _unit_width)                  \
 207 static int hpp__width_##_type(struct perf_hpp_fmt *fmt __maybe_unused,  \
 208                               struct perf_hpp *hpp __maybe_unused,      \
 209                               struct perf_evsel *evsel)                 \
 210 {                                                                       \
 211         int len = _min_width;                                           \
 212                                                                         \
 213         if (symbol_conf.event_group)                                    \
 214                 len = max(len, evsel->nr_members * _unit_width);        \
 215                                                                         \
 216         return len;                                                     \
 217 }
 218
 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
 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                                                                                 \
 253 static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,          \
 254                               struct perf_hpp *hpp, struct hist_entry *he)      \
 255 {                                                                               \
 256         return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%",                 \
 257                           hpp_color_scnprintf, true);                           \
 258 }
 259
 260 #define __HPP_ENTRY_PERCENT_FN(_type, _field)                                   \
 261 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused,         \
 262                               struct perf_hpp *hpp, struct hist_entry *he)      \
 263 {                                                                               \
 264         const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%";         \
 265         return __hpp__fmt(hpp, he, he_get_##_field, fmt,                        \
 266                           hpp_entry_scnprintf, true);                           \
 267 }
 268
 269 #define __HPP_SORT_FN(_type, _field)                                            \
 270 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b)    \
 271 {                                                                               \
 272         return __hpp__sort(a, b, he_get_##_field);                              \
 273 }
 274
 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
 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                                                                                 \
 309 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused,         \
 310                               struct perf_hpp *hpp, struct hist_entry *he)      \
 311 {                                                                               \
 312         const char *fmt = symbol_conf.field_sep ? " %"PRIu64 : " %11"PRIu64;    \
 313         return __hpp__fmt(hpp, he, he_get_raw_##_field, fmt,                    \
 314                           hpp_entry_scnprintf, false);                          \
 315 }
 316
 317 #define __HPP_SORT_RAW_FN(_type, _field)                                        \
 318 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b)    \
 319 {                                                                               \
 320         return __hpp__sort(a, b, he_get_raw_##_field);                          \
 321 }
 322
 323
 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)                                   \
 328 __HPP_ENTRY_PERCENT_FN(_type, _field)                                   \
 329 __HPP_SORT_FN(_type, _field)
 330
 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
 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)                          \
 341 __HPP_ENTRY_RAW_FN(_type, _field)                                       \
 342 __HPP_SORT_RAW_FN(_type, _field)
 343
 344 __HPP_HEADER_FN(overhead_self, "Self", 8, 8)
 345
 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)
 351 HPP_PERCENT_ACC_FNS(overhead_acc, "Children", period, 8, 8)
 352
 353 HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12)
 354 HPP_RAW_FNS(period, "Period", period, 12, 12)
 355
 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
 362 #define HPP__COLOR_PRINT_FNS(_name)                     \
 363         {                                               \
 364                 .header = hpp__header_ ## _name,        \
 365                 .width  = hpp__width_ ## _name,         \
 366                 .color  = hpp__color_ ## _name,         \
 367                 .entry  = hpp__entry_ ## _name,         \
 368                 .cmp    = hpp__nop_cmp,                 \
 369                 .collapse = hpp__nop_cmp,               \
 370                 .sort   = hpp__sort_ ## _name,          \
 371         }
 372
 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
 384 #define HPP__PRINT_FNS(_name)                           \
 385         {                                               \
 386                 .header = hpp__header_ ## _name,        \
 387                 .width  = hpp__width_ ## _name,         \
 388                 .entry  = hpp__entry_ ## _name,         \
 389                 .cmp    = hpp__nop_cmp,                 \
 390                 .collapse = hpp__nop_cmp,               \
 391                 .sort   = hpp__sort_ ## _name,          \
 392         }
 393
 394 struct perf_hpp_fmt perf_hpp__format[] = {
 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),
 400         HPP__COLOR_ACC_PRINT_FNS(overhead_acc),
 401         HPP__PRINT_FNS(samples),
 402         HPP__PRINT_FNS(period)
 403 };
 404
 405 LIST_HEAD(perf_hpp__list);
 406 LIST_HEAD(perf_hpp__sort_list);
 407
 408
 409 #undef HPP__COLOR_PRINT_FNS
 410 #undef HPP__COLOR_ACC_PRINT_FNS
 411 #undef HPP__PRINT_FNS
 412
 413 #undef HPP_PERCENT_FNS
 414 #undef HPP_PERCENT_ACC_FNS
 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
 421 #undef __HPP_COLOR_ACC_PERCENT_FN
 422 #undef __HPP_ENTRY_ACC_PERCENT_FN
 423 #undef __HPP_ENTRY_RAW_FN
 424 #undef __HPP_SORT_FN
 425 #undef __HPP_SORT_ACC_FN
 426 #undef __HPP_SORT_RAW_FN
 427
 428
 429 void perf_hpp__init(void)
 430 {
 431         struct list_head *list;
 432         int i;
 433
 434         for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
 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);
 442         }
 443
 444         /*
 445          * If user specified field order, no need to setup default fields.
 446          */
 447         if (field_order)
 448                 return;
 449
 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
 457         perf_hpp__column_enable(PERF_HPP__OVERHEAD);
 458
 459         if (symbol_conf.show_cpu_utilization) {
 460                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
 461                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);
 462
 463                 if (perf_guest) {
 464                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS);
 465                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US);
 466                 }
 467         }
 468
 469         if (symbol_conf.show_nr_samples)
 470                 perf_hpp__column_enable(PERF_HPP__SAMPLES);
 471
 472         if (symbol_conf.show_total_period)
 473                 perf_hpp__column_enable(PERF_HPP__PERIOD);
 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);
 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         }
 485 }
 486
 487 void perf_hpp__column_register(struct perf_hpp_fmt *format)
 488 {
 489         list_add_tail(&format->list, &perf_hpp__list);
 490 }
 491
 492 void perf_hpp__column_unregister(struct perf_hpp_fmt *format)
 493 {
 494         list_del(&format->list);
 495 }
 496
 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
 502 void perf_hpp__column_enable(unsigned col)
 503 {
 504         BUG_ON(col >= PERF_HPP__MAX_INDEX);
 505         perf_hpp__column_register(&perf_hpp__format[col]);
 506 }
 507
 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 {
 516         if (field_order)
 517                 return;
 518
 519         perf_hpp__column_disable(PERF_HPP__OVERHEAD_ACC);
 520         perf_hpp__format[PERF_HPP__OVERHEAD].header = hpp__header_overhead;
 521 }
 522
 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) {
 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;
 578         }
 579 }
 580
 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
 598 /*
 599  * See hists__fprintf to match the column widths
 600  */
 601 unsigned int hists__sort_list_width(struct hists *hists)
 602 {
 603         struct perf_hpp_fmt *fmt;
 604         int ret = 0;
 605         bool first = true;
 606         struct perf_hpp dummy_hpp;
 607
 608         perf_hpp__for_each_format(fmt) {
 609                 if (perf_hpp__should_skip(fmt))
 610                         continue;
 611
 612                 if (first)
 613                         first = false;
 614                 else
 615                         ret += 2;
 616
 617                 ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
 618         }
 619
 620         if (verbose && sort__has_sym) /* Addr + origin */
 621                 ret += 3 + BITS_PER_LONG / 4;
 622
 623         return ret;
 624 }