~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/ui/hist.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #define HPP__COLOR_PRINT_FNS(_name, _fn)                \
375         {                                               \
376                 .name   = _name,                        \
377                 .header = hpp__header_fn,               \
378                 .width  = hpp__width_fn,                \
379                 .color  = hpp__color_ ## _fn,           \
380                 .entry  = hpp__entry_ ## _fn,           \
381                 .cmp    = hpp__nop_cmp,                 \
382                 .collapse = hpp__nop_cmp,               \
383                 .sort   = hpp__sort_ ## _fn,            \
384         }
385 
386 #define HPP__COLOR_ACC_PRINT_FNS(_name, _fn)            \
387         {                                               \
388                 .name   = _name,                        \
389                 .header = hpp__header_fn,               \
390                 .width  = hpp__width_fn,                \
391                 .color  = hpp__color_ ## _fn,           \
392                 .entry  = hpp__entry_ ## _fn,           \
393                 .cmp    = hpp__nop_cmp,                 \
394                 .collapse = hpp__nop_cmp,               \
395                 .sort   = hpp__sort_ ## _fn,            \
396         }
397 
398 #define HPP__PRINT_FNS(_name, _fn)                      \
399         {                                               \
400                 .name   = _name,                        \
401                 .header = hpp__header_fn,               \
402                 .width  = hpp__width_fn,                \
403                 .entry  = hpp__entry_ ## _fn,           \
404                 .cmp    = hpp__nop_cmp,                 \
405                 .collapse = hpp__nop_cmp,               \
406                 .sort   = hpp__sort_ ## _fn,            \
407         }
408 
409 struct perf_hpp_fmt perf_hpp__format[] = {
410         HPP__COLOR_PRINT_FNS("Overhead", overhead),
411         HPP__COLOR_PRINT_FNS("sys", overhead_sys),
412         HPP__COLOR_PRINT_FNS("usr", overhead_us),
413         HPP__COLOR_PRINT_FNS("guest sys", overhead_guest_sys),
414         HPP__COLOR_PRINT_FNS("guest usr", overhead_guest_us),
415         HPP__COLOR_ACC_PRINT_FNS("Children", overhead_acc),
416         HPP__PRINT_FNS("Samples", samples),
417         HPP__PRINT_FNS("Period", period)
418 };
419 
420 LIST_HEAD(perf_hpp__list);
421 LIST_HEAD(perf_hpp__sort_list);
422 
423 
424 #undef HPP__COLOR_PRINT_FNS
425 #undef HPP__COLOR_ACC_PRINT_FNS
426 #undef HPP__PRINT_FNS
427 
428 #undef HPP_PERCENT_FNS
429 #undef HPP_PERCENT_ACC_FNS
430 #undef HPP_RAW_FNS
431 
432 #undef __HPP_HEADER_FN
433 #undef __HPP_WIDTH_FN
434 #undef __HPP_COLOR_PERCENT_FN
435 #undef __HPP_ENTRY_PERCENT_FN
436 #undef __HPP_COLOR_ACC_PERCENT_FN
437 #undef __HPP_ENTRY_ACC_PERCENT_FN
438 #undef __HPP_ENTRY_RAW_FN
439 #undef __HPP_SORT_FN
440 #undef __HPP_SORT_ACC_FN
441 #undef __HPP_SORT_RAW_FN
442 
443 
444 void perf_hpp__init(void)
445 {
446         struct list_head *list;
447         int i;
448 
449         for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
450                 struct perf_hpp_fmt *fmt = &perf_hpp__format[i];
451 
452                 INIT_LIST_HEAD(&fmt->list);
453 
454                 /* sort_list may be linked by setup_sorting() */
455                 if (fmt->sort_list.next == NULL)
456                         INIT_LIST_HEAD(&fmt->sort_list);
457         }
458 
459         /*
460          * If user specified field order, no need to setup default fields.
461          */
462         if (is_strict_order(field_order))
463                 return;
464 
465         if (symbol_conf.cumulate_callchain) {
466                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_ACC);
467                 perf_hpp__format[PERF_HPP__OVERHEAD].name = "Self";
468         }
469 
470         perf_hpp__column_enable(PERF_HPP__OVERHEAD);
471 
472         if (symbol_conf.show_cpu_utilization) {
473                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
474                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);
475 
476                 if (perf_guest) {
477                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS);
478                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US);
479                 }
480         }
481 
482         if (symbol_conf.show_nr_samples)
483                 perf_hpp__column_enable(PERF_HPP__SAMPLES);
484 
485         if (symbol_conf.show_total_period)
486                 perf_hpp__column_enable(PERF_HPP__PERIOD);
487 
488         /* prepend overhead field for backward compatiblity.  */
489         list = &perf_hpp__format[PERF_HPP__OVERHEAD].sort_list;
490         if (list_empty(list))
491                 list_add(list, &perf_hpp__sort_list);
492 
493         if (symbol_conf.cumulate_callchain) {
494                 list = &perf_hpp__format[PERF_HPP__OVERHEAD_ACC].sort_list;
495                 if (list_empty(list))
496                         list_add(list, &perf_hpp__sort_list);
497         }
498 }
499 
500 void perf_hpp__column_register(struct perf_hpp_fmt *format)
501 {
502         list_add_tail(&format->list, &perf_hpp__list);
503 }
504 
505 void perf_hpp__column_unregister(struct perf_hpp_fmt *format)
506 {
507         list_del(&format->list);
508 }
509 
510 void perf_hpp__register_sort_field(struct perf_hpp_fmt *format)
511 {
512         list_add_tail(&format->sort_list, &perf_hpp__sort_list);
513 }
514 
515 void perf_hpp__column_enable(unsigned col)
516 {
517         BUG_ON(col >= PERF_HPP__MAX_INDEX);
518         perf_hpp__column_register(&perf_hpp__format[col]);
519 }
520 
521 void perf_hpp__column_disable(unsigned col)
522 {
523         BUG_ON(col >= PERF_HPP__MAX_INDEX);
524         perf_hpp__column_unregister(&perf_hpp__format[col]);
525 }
526 
527 void perf_hpp__cancel_cumulate(void)
528 {
529         if (is_strict_order(field_order))
530                 return;
531 
532         perf_hpp__column_disable(PERF_HPP__OVERHEAD_ACC);
533         perf_hpp__format[PERF_HPP__OVERHEAD].name = "Overhead";
534 }
535 
536 void perf_hpp__setup_output_field(void)
537 {
538         struct perf_hpp_fmt *fmt;
539 
540         /* append sort keys to output field */
541         perf_hpp__for_each_sort_list(fmt) {
542                 if (!list_empty(&fmt->list))
543                         continue;
544 
545                 /*
546                  * sort entry fields are dynamically created,
547                  * so they can share a same sort key even though
548                  * the list is empty.
549                  */
550                 if (perf_hpp__is_sort_entry(fmt)) {
551                         struct perf_hpp_fmt *pos;
552 
553                         perf_hpp__for_each_format(pos) {
554                                 if (perf_hpp__same_sort_entry(pos, fmt))
555                                         goto next;
556                         }
557                 }
558 
559                 perf_hpp__column_register(fmt);
560 next:
561                 continue;
562         }
563 }
564 
565 void perf_hpp__append_sort_keys(void)
566 {
567         struct perf_hpp_fmt *fmt;
568 
569         /* append output fields to sort keys */
570         perf_hpp__for_each_format(fmt) {
571                 if (!list_empty(&fmt->sort_list))
572                         continue;
573 
574                 /*
575                  * sort entry fields are dynamically created,
576                  * so they can share a same sort key even though
577                  * the list is empty.
578                  */
579                 if (perf_hpp__is_sort_entry(fmt)) {
580                         struct perf_hpp_fmt *pos;
581 
582                         perf_hpp__for_each_sort_list(pos) {
583                                 if (perf_hpp__same_sort_entry(pos, fmt))
584                                         goto next;
585                         }
586                 }
587 
588                 perf_hpp__register_sort_field(fmt);
589 next:
590                 continue;
591         }
592 }
593 
594 void perf_hpp__reset_output_field(void)
595 {
596         struct perf_hpp_fmt *fmt, *tmp;
597 
598         /* reset output fields */
599         perf_hpp__for_each_format_safe(fmt, tmp) {
600                 list_del_init(&fmt->list);
601                 list_del_init(&fmt->sort_list);
602         }
603 
604         /* reset sort keys */
605         perf_hpp__for_each_sort_list_safe(fmt, tmp) {
606                 list_del_init(&fmt->list);
607                 list_del_init(&fmt->sort_list);
608         }
609 }
610 
611 /*
612  * See hists__fprintf to match the column widths
613  */
614 unsigned int hists__sort_list_width(struct hists *hists)
615 {
616         struct perf_hpp_fmt *fmt;
617         int ret = 0;
618         bool first = true;
619         struct perf_hpp dummy_hpp;
620 
621         perf_hpp__for_each_format(fmt) {
622                 if (perf_hpp__should_skip(fmt))
623                         continue;
624 
625                 if (first)
626                         first = false;
627                 else
628                         ret += 2;
629 
630                 ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
631         }
632 
633         if (verbose && sort__has_sym) /* Addr + origin */
634                 ret += 3 + BITS_PER_LONG / 4;
635 
636         return ret;
637 }
638 
639 void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists)
640 {
641         int idx;
642 
643         if (perf_hpp__is_sort_entry(fmt))
644                 return perf_hpp__reset_sort_width(fmt, hists);
645 
646         for (idx = 0; idx < PERF_HPP__MAX_INDEX; idx++) {
647                 if (fmt == &perf_hpp__format[idx])
648                         break;
649         }
650 
651         if (idx == PERF_HPP__MAX_INDEX)
652                 return;
653 
654         switch (idx) {
655         case PERF_HPP__OVERHEAD:
656         case PERF_HPP__OVERHEAD_SYS:
657         case PERF_HPP__OVERHEAD_US:
658         case PERF_HPP__OVERHEAD_ACC:
659                 fmt->len = 8;
660                 break;
661 
662         case PERF_HPP__OVERHEAD_GUEST_SYS:
663         case PERF_HPP__OVERHEAD_GUEST_US:
664                 fmt->len = 9;
665                 break;
666 
667         case PERF_HPP__SAMPLES:
668         case PERF_HPP__PERIOD:
669                 fmt->len = 12;
670                 break;
671 
672         default:
673                 break;
674         }
675 }
676 
677 void perf_hpp__set_user_width(const char *width_list_str)
678 {
679         struct perf_hpp_fmt *fmt;
680         const char *ptr = width_list_str;
681 
682         perf_hpp__for_each_format(fmt) {
683                 char *p;
684 
685                 int len = strtol(ptr, &p, 10);
686                 fmt->user_len = len;
687 
688                 if (*p == ',')
689                         ptr = p + 1;
690                 else
691                         break;
692         }
693 }
694 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp