perf hists: Make hpp setup function generic
[cascardo/linux.git] / 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 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)
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, len, percent);
36         } else
37                 ret = hpp__call_print_fn(hpp, print_fn, fmt, len, 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, len, 0.0);
64                                 } else {
65                                         ret += hpp__call_print_fn(hpp, print_fn,
66                                                                   fmt, len, 0ULL);
67                                 }
68                         }
69
70                         if (fmt_percent) {
71                                 ret += hpp__call_print_fn(hpp, print_fn, fmt, len,
72                                                           100.0 * period / total);
73                         } else {
74                                 ret += hpp__call_print_fn(hpp, print_fn, fmt,
75                                                           len, 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, len, 0.0);
90                         } else {
91                                 ret += hpp__call_print_fn(hpp, print_fn,
92                                                           fmt, len, 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(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)
129 {
130         if (!symbol_conf.cumulate_callchain) {
131                 int len = fmt->user_len ?: fmt->len;
132                 return snprintf(hpp->buf, hpp->size, " %*s", len - 1, "N/A");
133         }
134
135         return hpp__fmt(fmt, hpp, he, get_field, fmtstr, print_fn, fmt_percent);
136 }
137
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;
165         fields_a = calloc(nr_members, sizeof(*fields_a));
166         fields_b = calloc(nr_members, sizeof(*fields_b));
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
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                 if (a->thread != b->thread || !symbol_conf.use_callchain)
208                         return 0;
209
210                 ret = b->callchain->max_depth - a->callchain->max_depth;
211         }
212         return ret;
213 }
214
215 static int hpp__width_fn(struct perf_hpp_fmt *fmt,
216                          struct perf_hpp *hpp __maybe_unused,
217                          struct perf_evsel *evsel)
218 {
219         int len = fmt->user_len ?: fmt->len;
220
221         if (symbol_conf.event_group)
222                 len = max(len, evsel->nr_members * fmt->len);
223
224         if (len < (int)strlen(fmt->name))
225                 len = strlen(fmt->name);
226
227         return len;
228 }
229
230 static int hpp__header_fn(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
231                           struct perf_evsel *evsel)
232 {
233         int len = hpp__width_fn(fmt, hpp, evsel);
234         return scnprintf(hpp->buf, hpp->size, "%*s", len, fmt->name);
235 }
236
237 static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
238 {
239         va_list args;
240         ssize_t ssize = hpp->size;
241         double percent;
242         int ret, len;
243
244         va_start(args, fmt);
245         len = va_arg(args, int);
246         percent = va_arg(args, double);
247         ret = percent_color_len_snprintf(hpp->buf, hpp->size, fmt, len, percent);
248         va_end(args);
249
250         return (ret >= ssize) ? (ssize - 1) : ret;
251 }
252
253 static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
254 {
255         va_list args;
256         ssize_t ssize = hpp->size;
257         int ret;
258
259         va_start(args, fmt);
260         ret = vsnprintf(hpp->buf, hpp->size, fmt, args);
261         va_end(args);
262
263         return (ret >= ssize) ? (ssize - 1) : ret;
264 }
265
266 #define __HPP_COLOR_PERCENT_FN(_type, _field)                                   \
267 static u64 he_get_##_field(struct hist_entry *he)                               \
268 {                                                                               \
269         return he->stat._field;                                                 \
270 }                                                                               \
271                                                                                 \
272 static int hpp__color_##_type(struct perf_hpp_fmt *fmt,                         \
273                               struct perf_hpp *hpp, struct hist_entry *he)      \
274 {                                                                               \
275         return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%",              \
276                         hpp_color_scnprintf, true);                             \
277 }
278
279 #define __HPP_ENTRY_PERCENT_FN(_type, _field)                                   \
280 static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,                         \
281                               struct perf_hpp *hpp, struct hist_entry *he)      \
282 {                                                                               \
283         return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%",              \
284                         hpp_entry_scnprintf, true);                             \
285 }
286
287 #define __HPP_SORT_FN(_type, _field)                                            \
288 static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused,       \
289                                  struct hist_entry *a, struct hist_entry *b)    \
290 {                                                                               \
291         return __hpp__sort(a, b, he_get_##_field);                              \
292 }
293
294 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field)                               \
295 static u64 he_get_acc_##_field(struct hist_entry *he)                           \
296 {                                                                               \
297         return he->stat_acc->_field;                                            \
298 }                                                                               \
299                                                                                 \
300 static int hpp__color_##_type(struct perf_hpp_fmt *fmt,                         \
301                               struct perf_hpp *hpp, struct hist_entry *he)      \
302 {                                                                               \
303         return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%",      \
304                             hpp_color_scnprintf, true);                         \
305 }
306
307 #define __HPP_ENTRY_ACC_PERCENT_FN(_type, _field)                               \
308 static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,                         \
309                               struct perf_hpp *hpp, struct hist_entry *he)      \
310 {                                                                               \
311         return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%",      \
312                             hpp_entry_scnprintf, true);                         \
313 }
314
315 #define __HPP_SORT_ACC_FN(_type, _field)                                        \
316 static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused,       \
317                                  struct hist_entry *a, struct hist_entry *b)    \
318 {                                                                               \
319         return __hpp__sort_acc(a, b, he_get_acc_##_field);                      \
320 }
321
322 #define __HPP_ENTRY_RAW_FN(_type, _field)                                       \
323 static u64 he_get_raw_##_field(struct hist_entry *he)                           \
324 {                                                                               \
325         return he->stat._field;                                                 \
326 }                                                                               \
327                                                                                 \
328 static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,                         \
329                               struct perf_hpp *hpp, struct hist_entry *he)      \
330 {                                                                               \
331         return hpp__fmt(fmt, hpp, he, he_get_raw_##_field, " %*"PRIu64,         \
332                         hpp_entry_scnprintf, false);                            \
333 }
334
335 #define __HPP_SORT_RAW_FN(_type, _field)                                        \
336 static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused,       \
337                                  struct hist_entry *a, struct hist_entry *b)    \
338 {                                                                               \
339         return __hpp__sort(a, b, he_get_raw_##_field);                          \
340 }
341
342
343 #define HPP_PERCENT_FNS(_type, _field)                                  \
344 __HPP_COLOR_PERCENT_FN(_type, _field)                                   \
345 __HPP_ENTRY_PERCENT_FN(_type, _field)                                   \
346 __HPP_SORT_FN(_type, _field)
347
348 #define HPP_PERCENT_ACC_FNS(_type, _field)                              \
349 __HPP_COLOR_ACC_PERCENT_FN(_type, _field)                               \
350 __HPP_ENTRY_ACC_PERCENT_FN(_type, _field)                               \
351 __HPP_SORT_ACC_FN(_type, _field)
352
353 #define HPP_RAW_FNS(_type, _field)                                      \
354 __HPP_ENTRY_RAW_FN(_type, _field)                                       \
355 __HPP_SORT_RAW_FN(_type, _field)
356
357 HPP_PERCENT_FNS(overhead, period)
358 HPP_PERCENT_FNS(overhead_sys, period_sys)
359 HPP_PERCENT_FNS(overhead_us, period_us)
360 HPP_PERCENT_FNS(overhead_guest_sys, period_guest_sys)
361 HPP_PERCENT_FNS(overhead_guest_us, period_guest_us)
362 HPP_PERCENT_ACC_FNS(overhead_acc, period)
363
364 HPP_RAW_FNS(samples, nr_events)
365 HPP_RAW_FNS(period, period)
366
367 static int64_t hpp__nop_cmp(struct perf_hpp_fmt *fmt __maybe_unused,
368                             struct hist_entry *a __maybe_unused,
369                             struct hist_entry *b __maybe_unused)
370 {
371         return 0;
372 }
373
374 static bool perf_hpp__is_hpp_entry(struct perf_hpp_fmt *a)
375 {
376         return a->header == hpp__header_fn;
377 }
378
379 static bool hpp__equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
380 {
381         if (!perf_hpp__is_hpp_entry(a) || !perf_hpp__is_hpp_entry(b))
382                 return false;
383
384         return a->idx == b->idx;
385 }
386
387 #define HPP__COLOR_PRINT_FNS(_name, _fn, _idx)          \
388         {                                               \
389                 .name   = _name,                        \
390                 .header = hpp__header_fn,               \
391                 .width  = hpp__width_fn,                \
392                 .color  = hpp__color_ ## _fn,           \
393                 .entry  = hpp__entry_ ## _fn,           \
394                 .cmp    = hpp__nop_cmp,                 \
395                 .collapse = hpp__nop_cmp,               \
396                 .sort   = hpp__sort_ ## _fn,            \
397                 .idx    = PERF_HPP__ ## _idx,           \
398                 .equal  = hpp__equal,                   \
399         }
400
401 #define HPP__COLOR_ACC_PRINT_FNS(_name, _fn, _idx)      \
402         {                                               \
403                 .name   = _name,                        \
404                 .header = hpp__header_fn,               \
405                 .width  = hpp__width_fn,                \
406                 .color  = hpp__color_ ## _fn,           \
407                 .entry  = hpp__entry_ ## _fn,           \
408                 .cmp    = hpp__nop_cmp,                 \
409                 .collapse = hpp__nop_cmp,               \
410                 .sort   = hpp__sort_ ## _fn,            \
411                 .idx    = PERF_HPP__ ## _idx,           \
412                 .equal  = hpp__equal,                   \
413         }
414
415 #define HPP__PRINT_FNS(_name, _fn, _idx)                \
416         {                                               \
417                 .name   = _name,                        \
418                 .header = hpp__header_fn,               \
419                 .width  = hpp__width_fn,                \
420                 .entry  = hpp__entry_ ## _fn,           \
421                 .cmp    = hpp__nop_cmp,                 \
422                 .collapse = hpp__nop_cmp,               \
423                 .sort   = hpp__sort_ ## _fn,            \
424                 .idx    = PERF_HPP__ ## _idx,           \
425                 .equal  = hpp__equal,                   \
426         }
427
428 struct perf_hpp_fmt perf_hpp__format[] = {
429         HPP__COLOR_PRINT_FNS("Overhead", overhead, OVERHEAD),
430         HPP__COLOR_PRINT_FNS("sys", overhead_sys, OVERHEAD_SYS),
431         HPP__COLOR_PRINT_FNS("usr", overhead_us, OVERHEAD_US),
432         HPP__COLOR_PRINT_FNS("guest sys", overhead_guest_sys, OVERHEAD_GUEST_SYS),
433         HPP__COLOR_PRINT_FNS("guest usr", overhead_guest_us, OVERHEAD_GUEST_US),
434         HPP__COLOR_ACC_PRINT_FNS("Children", overhead_acc, OVERHEAD_ACC),
435         HPP__PRINT_FNS("Samples", samples, SAMPLES),
436         HPP__PRINT_FNS("Period", period, PERIOD)
437 };
438
439 LIST_HEAD(perf_hpp__list);
440 LIST_HEAD(perf_hpp__sort_list);
441
442
443 #undef HPP__COLOR_PRINT_FNS
444 #undef HPP__COLOR_ACC_PRINT_FNS
445 #undef HPP__PRINT_FNS
446
447 #undef HPP_PERCENT_FNS
448 #undef HPP_PERCENT_ACC_FNS
449 #undef HPP_RAW_FNS
450
451 #undef __HPP_HEADER_FN
452 #undef __HPP_WIDTH_FN
453 #undef __HPP_COLOR_PERCENT_FN
454 #undef __HPP_ENTRY_PERCENT_FN
455 #undef __HPP_COLOR_ACC_PERCENT_FN
456 #undef __HPP_ENTRY_ACC_PERCENT_FN
457 #undef __HPP_ENTRY_RAW_FN
458 #undef __HPP_SORT_FN
459 #undef __HPP_SORT_ACC_FN
460 #undef __HPP_SORT_RAW_FN
461
462
463 void perf_hpp__init(void)
464 {
465         int i;
466
467         for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
468                 struct perf_hpp_fmt *fmt = &perf_hpp__format[i];
469
470                 INIT_LIST_HEAD(&fmt->list);
471
472                 /* sort_list may be linked by setup_sorting() */
473                 if (fmt->sort_list.next == NULL)
474                         INIT_LIST_HEAD(&fmt->sort_list);
475         }
476
477         /*
478          * If user specified field order, no need to setup default fields.
479          */
480         if (is_strict_order(field_order))
481                 return;
482
483         if (symbol_conf.cumulate_callchain) {
484                 hpp_dimension__add_output(PERF_HPP__OVERHEAD_ACC);
485                 perf_hpp__format[PERF_HPP__OVERHEAD].name = "Self";
486         }
487
488         hpp_dimension__add_output(PERF_HPP__OVERHEAD);
489
490         if (symbol_conf.show_cpu_utilization) {
491                 hpp_dimension__add_output(PERF_HPP__OVERHEAD_SYS);
492                 hpp_dimension__add_output(PERF_HPP__OVERHEAD_US);
493
494                 if (perf_guest) {
495                         hpp_dimension__add_output(PERF_HPP__OVERHEAD_GUEST_SYS);
496                         hpp_dimension__add_output(PERF_HPP__OVERHEAD_GUEST_US);
497                 }
498         }
499
500         if (symbol_conf.show_nr_samples)
501                 hpp_dimension__add_output(PERF_HPP__SAMPLES);
502
503         if (symbol_conf.show_total_period)
504                 hpp_dimension__add_output(PERF_HPP__PERIOD);
505 }
506
507 void perf_hpp__column_register(struct perf_hpp_fmt *format)
508 {
509         list_add_tail(&format->list, &perf_hpp__list);
510 }
511
512 void perf_hpp__column_unregister(struct perf_hpp_fmt *format)
513 {
514         list_del(&format->list);
515 }
516
517 void perf_hpp__register_sort_field(struct perf_hpp_fmt *format)
518 {
519         list_add_tail(&format->sort_list, &perf_hpp__sort_list);
520 }
521
522 void perf_hpp__column_enable(unsigned col)
523 {
524         BUG_ON(col >= PERF_HPP__MAX_INDEX);
525         perf_hpp__column_register(&perf_hpp__format[col]);
526 }
527
528 void perf_hpp__column_disable(unsigned col)
529 {
530         BUG_ON(col >= PERF_HPP__MAX_INDEX);
531         perf_hpp__column_unregister(&perf_hpp__format[col]);
532 }
533
534 void perf_hpp__cancel_cumulate(void)
535 {
536         if (is_strict_order(field_order))
537                 return;
538
539         perf_hpp__column_disable(PERF_HPP__OVERHEAD_ACC);
540         perf_hpp__format[PERF_HPP__OVERHEAD].name = "Overhead";
541 }
542
543 static bool fmt_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
544 {
545         return a->equal && a->equal(a, b);
546 }
547
548 void perf_hpp__setup_output_field(void)
549 {
550         struct perf_hpp_fmt *fmt;
551
552         /* append sort keys to output field */
553         perf_hpp__for_each_sort_list(fmt) {
554                 struct perf_hpp_fmt *pos;
555
556                 perf_hpp__for_each_format(pos) {
557                         if (fmt_equal(fmt, pos))
558                                 goto next;
559                 }
560
561                 perf_hpp__column_register(fmt);
562 next:
563                 continue;
564         }
565 }
566
567 void perf_hpp__append_sort_keys(void)
568 {
569         struct perf_hpp_fmt *fmt;
570
571         /* append output fields to sort keys */
572         perf_hpp__for_each_format(fmt) {
573                 struct perf_hpp_fmt *pos;
574
575                 perf_hpp__for_each_sort_list(pos) {
576                         if (fmt_equal(fmt, pos))
577                                 goto next;
578                 }
579
580                 perf_hpp__register_sort_field(fmt);
581 next:
582                 continue;
583         }
584 }
585
586 void perf_hpp__reset_output_field(void)
587 {
588         struct perf_hpp_fmt *fmt, *tmp;
589
590         /* reset output fields */
591         perf_hpp__for_each_format_safe(fmt, tmp) {
592                 list_del_init(&fmt->list);
593                 list_del_init(&fmt->sort_list);
594         }
595
596         /* reset sort keys */
597         perf_hpp__for_each_sort_list_safe(fmt, tmp) {
598                 list_del_init(&fmt->list);
599                 list_del_init(&fmt->sort_list);
600         }
601 }
602
603 /*
604  * See hists__fprintf to match the column widths
605  */
606 unsigned int hists__sort_list_width(struct hists *hists)
607 {
608         struct perf_hpp_fmt *fmt;
609         int ret = 0;
610         bool first = true;
611         struct perf_hpp dummy_hpp;
612
613         perf_hpp__for_each_format(fmt) {
614                 if (perf_hpp__should_skip(fmt, hists))
615                         continue;
616
617                 if (first)
618                         first = false;
619                 else
620                         ret += 2;
621
622                 ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
623         }
624
625         if (verbose && sort__has_sym) /* Addr + origin */
626                 ret += 3 + BITS_PER_LONG / 4;
627
628         return ret;
629 }
630
631 void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists)
632 {
633         if (perf_hpp__is_sort_entry(fmt))
634                 return perf_hpp__reset_sort_width(fmt, hists);
635
636         BUG_ON(fmt->idx >= PERF_HPP__MAX_INDEX);
637
638         switch (fmt->idx) {
639         case PERF_HPP__OVERHEAD:
640         case PERF_HPP__OVERHEAD_SYS:
641         case PERF_HPP__OVERHEAD_US:
642         case PERF_HPP__OVERHEAD_ACC:
643                 fmt->len = 8;
644                 break;
645
646         case PERF_HPP__OVERHEAD_GUEST_SYS:
647         case PERF_HPP__OVERHEAD_GUEST_US:
648                 fmt->len = 9;
649                 break;
650
651         case PERF_HPP__SAMPLES:
652         case PERF_HPP__PERIOD:
653                 fmt->len = 12;
654                 break;
655
656         default:
657                 break;
658         }
659 }
660
661 void perf_hpp__set_user_width(const char *width_list_str)
662 {
663         struct perf_hpp_fmt *fmt;
664         const char *ptr = width_list_str;
665
666         perf_hpp__for_each_format(fmt) {
667                 char *p;
668
669                 int len = strtol(ptr, &p, 10);
670                 fmt->user_len = len;
671
672                 if (*p == ',')
673                         ptr = p + 1;
674                 else
675                         break;
676         }
677 }