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, hpp_callback_fn callback,
  20                const char *fmt, hpp_snprint_fn print_fn, bool fmt_percent)
  21 {
  22         int ret = 0;
  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 (callback) {
  29                 ret = callback(hpp, true);
  30                 advance_hpp(hpp, ret);
  31         }
  32
  33         if (fmt_percent) {
  34                 double percent = 0.0;
  35
  36                 if (hists->stats.total_period)
  37                         percent = 100.0 * get_field(he) /
  38                                   hists->stats.total_period;
  39
  40                 ret += hpp__call_print_fn(hpp, print_fn, fmt, percent);
  41         } else
  42                 ret += hpp__call_print_fn(hpp, print_fn, fmt, get_field(he));
  43
  44         if (perf_evsel__is_group_event(evsel)) {
  45                 int prev_idx, idx_delta;
  46                 struct hist_entry *pair;
  47                 int nr_members = evsel->nr_members;
  48
  49                 prev_idx = perf_evsel__group_idx(evsel);
  50
  51                 list_for_each_entry(pair, &he->pairs.head, pairs.node) {
  52                         u64 period = get_field(pair);
  53                         u64 total = pair->hists->stats.total_period;
  54
  55                         if (!total)
  56                                 continue;
  57
  58                         evsel = hists_to_evsel(pair->hists);
  59                         idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;
  60
  61                         while (idx_delta--) {
  62                                 /*
  63                                  * zero-fill group members in the middle which
  64                                  * have no sample
  65                                  */
  66                                 if (fmt_percent) {
  67                                         ret += hpp__call_print_fn(hpp, print_fn,
  68                                                                   fmt, 0.0);
  69                                 } else {
  70                                         ret += hpp__call_print_fn(hpp, print_fn,
  71                                                                   fmt, 0ULL);
  72                                 }
  73                         }
  74
  75                         if (fmt_percent) {
  76                                 ret += hpp__call_print_fn(hpp, print_fn, fmt,
  77                                                           100.0 * period / total);
  78                         } else {
  79                                 ret += hpp__call_print_fn(hpp, print_fn, fmt,
  80                                                           period);
  81                         }
  82
  83                         prev_idx = perf_evsel__group_idx(evsel);
  84                 }
  85
  86                 idx_delta = nr_members - prev_idx - 1;
  87
  88                 while (idx_delta--) {
  89                         /*
  90                          * zero-fill group members at last which have no sample
  91                          */
  92                         if (fmt_percent) {
  93                                 ret += hpp__call_print_fn(hpp, print_fn,
  94                                                           fmt, 0.0);
  95                         } else {
  96                                 ret += hpp__call_print_fn(hpp, print_fn,
  97                                                           fmt, 0ULL);
  98                         }
  99                 }
 100         }
 101
 102         if (callback) {
 103                 int __ret = callback(hpp, false);
 104
 105                 advance_hpp(hpp, __ret);
 106                 ret += __ret;
 107         }
 108
 109         /*
 110          * Restore original buf and size as it's where caller expects
 111          * the result will be saved.
 112          */
 113         hpp->buf = buf;
 114         hpp->size = size;
 115
 116         return ret;
 117 }
 118
 119 #define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width)           \
 120 static int hpp__header_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
 121                                struct perf_hpp *hpp,                    \
 122                                struct perf_evsel *evsel)                \
 123 {                                                                       \
 124         int len = _min_width;                                           \
 125                                                                         \
 126         if (symbol_conf.event_group)                                    \
 127                 len = max(len, evsel->nr_members * _unit_width);        \
 128                                                                         \
 129         return scnprintf(hpp->buf, hpp->size, "%*s", len, _str);        \
 130 }
 131
 132 #define __HPP_WIDTH_FN(_type, _min_width, _unit_width)                  \
 133 static int hpp__width_##_type(struct perf_hpp_fmt *fmt __maybe_unused,  \
 134                               struct perf_hpp *hpp __maybe_unused,      \
 135                               struct perf_evsel *evsel)                 \
 136 {                                                                       \
 137         int len = _min_width;                                           \
 138                                                                         \
 139         if (symbol_conf.event_group)                                    \
 140                 len = max(len, evsel->nr_members * _unit_width);        \
 141                                                                         \
 142         return len;                                                     \
 143 }
 144
 145 static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
 146 {
 147         va_list args;
 148         ssize_t ssize = hpp->size;
 149         double percent;
 150         int ret;
 151
 152         va_start(args, fmt);
 153         percent = va_arg(args, double);
 154         ret = value_color_snprintf(hpp->buf, hpp->size, fmt, percent);
 155         va_end(args);
 156
 157         return (ret >= ssize) ? (ssize - 1) : ret;
 158 }
 159
 160 static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
 161 {
 162         va_list args;
 163         ssize_t ssize = hpp->size;
 164         int ret;
 165
 166         va_start(args, fmt);
 167         ret = vsnprintf(hpp->buf, hpp->size, fmt, args);
 168         va_end(args);
 169
 170         return (ret >= ssize) ? (ssize - 1) : ret;
 171 }
 172
 173 #define __HPP_COLOR_PERCENT_FN(_type, _field)                                   \
 174 static u64 he_get_##_field(struct hist_entry *he)                               \
 175 {                                                                               \
 176         return he->stat._field;                                                 \
 177 }                                                                               \
 178                                                                                 \
 179 static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,          \
 180                               struct perf_hpp *hpp, struct hist_entry *he)      \
 181 {                                                                               \
 182         return __hpp__fmt(hpp, he, he_get_##_field, NULL, " %6.2f%%",           \
 183                           hpp_color_scnprintf, true);                           \
 184 }
 185
 186 #define __HPP_ENTRY_PERCENT_FN(_type, _field)                                   \
 187 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused,         \
 188                               struct perf_hpp *hpp, struct hist_entry *he)      \
 189 {                                                                               \
 190         const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%";         \
 191         return __hpp__fmt(hpp, he, he_get_##_field, NULL, fmt,                  \
 192                           hpp_entry_scnprintf, true);                           \
 193 }
 194
 195 #define __HPP_ENTRY_RAW_FN(_type, _field)                                       \
 196 static u64 he_get_raw_##_field(struct hist_entry *he)                           \
 197 {                                                                               \
 198         return he->stat._field;                                                 \
 199 }                                                                               \
 200                                                                                 \
 201 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused,         \
 202                               struct perf_hpp *hpp, struct hist_entry *he)      \
 203 {                                                                               \
 204         const char *fmt = symbol_conf.field_sep ? " %"PRIu64 : " %11"PRIu64;    \
 205         return __hpp__fmt(hpp, he, he_get_raw_##_field, NULL, fmt,              \
 206                           hpp_entry_scnprintf, false);                          \
 207 }
 208
 209 #define HPP_PERCENT_FNS(_type, _str, _field, _min_width, _unit_width)   \
 210 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width)                   \
 211 __HPP_WIDTH_FN(_type, _min_width, _unit_width)                          \
 212 __HPP_COLOR_PERCENT_FN(_type, _field)                                   \
 213 __HPP_ENTRY_PERCENT_FN(_type, _field)
 214
 215 #define HPP_RAW_FNS(_type, _str, _field, _min_width, _unit_width)       \
 216 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width)                   \
 217 __HPP_WIDTH_FN(_type, _min_width, _unit_width)                          \
 218 __HPP_ENTRY_RAW_FN(_type, _field)
 219
 220
 221 HPP_PERCENT_FNS(overhead, "Overhead", period, 8, 8)
 222 HPP_PERCENT_FNS(overhead_sys, "sys", period_sys, 8, 8)
 223 HPP_PERCENT_FNS(overhead_us, "usr", period_us, 8, 8)
 224 HPP_PERCENT_FNS(overhead_guest_sys, "guest sys", period_guest_sys, 9, 8)
 225 HPP_PERCENT_FNS(overhead_guest_us, "guest usr", period_guest_us, 9, 8)
 226
 227 HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12)
 228 HPP_RAW_FNS(period, "Period", period, 12, 12)
 229
 230 #define HPP__COLOR_PRINT_FNS(_name)                     \
 231         {                                               \
 232                 .header = hpp__header_ ## _name,        \
 233                 .width  = hpp__width_ ## _name,         \
 234                 .color  = hpp__color_ ## _name,         \
 235                 .entry  = hpp__entry_ ## _name          \
 236         }
 237
 238 #define HPP__PRINT_FNS(_name)                           \
 239         {                                               \
 240                 .header = hpp__header_ ## _name,        \
 241                 .width  = hpp__width_ ## _name,         \
 242                 .entry  = hpp__entry_ ## _name          \
 243         }
 244
 245 struct perf_hpp_fmt perf_hpp__format[] = {
 246         HPP__COLOR_PRINT_FNS(overhead),
 247         HPP__COLOR_PRINT_FNS(overhead_sys),
 248         HPP__COLOR_PRINT_FNS(overhead_us),
 249         HPP__COLOR_PRINT_FNS(overhead_guest_sys),
 250         HPP__COLOR_PRINT_FNS(overhead_guest_us),
 251         HPP__PRINT_FNS(samples),
 252         HPP__PRINT_FNS(period)
 253 };
 254
 255 LIST_HEAD(perf_hpp__list);
 256
 257
 258 #undef HPP__COLOR_PRINT_FNS
 259 #undef HPP__PRINT_FNS
 260
 261 #undef HPP_PERCENT_FNS
 262 #undef HPP_RAW_FNS
 263
 264 #undef __HPP_HEADER_FN
 265 #undef __HPP_WIDTH_FN
 266 #undef __HPP_COLOR_PERCENT_FN
 267 #undef __HPP_ENTRY_PERCENT_FN
 268 #undef __HPP_ENTRY_RAW_FN
 269
 270
 271 void perf_hpp__init(void)
 272 {
 273         perf_hpp__column_enable(PERF_HPP__OVERHEAD);
 274
 275         if (symbol_conf.show_cpu_utilization) {
 276                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
 277                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);
 278
 279                 if (perf_guest) {
 280                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS);
 281                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US);
 282                 }
 283         }
 284
 285         if (symbol_conf.show_nr_samples)
 286                 perf_hpp__column_enable(PERF_HPP__SAMPLES);
 287
 288         if (symbol_conf.show_total_period)
 289                 perf_hpp__column_enable(PERF_HPP__PERIOD);
 290 }
 291
 292 void perf_hpp__column_register(struct perf_hpp_fmt *format)
 293 {
 294         list_add_tail(&format->list, &perf_hpp__list);
 295 }
 296
 297 void perf_hpp__column_enable(unsigned col)
 298 {
 299         BUG_ON(col >= PERF_HPP__MAX_INDEX);
 300         perf_hpp__column_register(&perf_hpp__format[col]);
 301 }
 302
 303 int hist_entry__sort_snprintf(struct hist_entry *he, char *s, size_t size,
 304                               struct hists *hists)
 305 {
 306         const char *sep = symbol_conf.field_sep;
 307         struct sort_entry *se;
 308         int ret = 0;
 309
 310         list_for_each_entry(se, &hist_entry__sort_list, list) {
 311                 if (se->elide)
 312                         continue;
 313
 314                 ret += scnprintf(s + ret, size - ret, "%s", sep ?: "  ");
 315                 ret += se->se_snprintf(he, s + ret, size - ret,
 316                                        hists__col_len(hists, se->se_width_idx));
 317         }
 318
 319         return ret;
 320 }
 321
 322 /*
 323  * See hists__fprintf to match the column widths
 324  */
 325 unsigned int hists__sort_list_width(struct hists *hists)
 326 {
 327         struct perf_hpp_fmt *fmt;
 328         struct sort_entry *se;
 329         int i = 0, ret = 0;
 330         struct perf_hpp dummy_hpp;
 331
 332         perf_hpp__for_each_format(fmt) {
 333                 if (i)
 334                         ret += 2;
 335
 336                 ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
 337         }
 338
 339         list_for_each_entry(se, &hist_entry__sort_list, list)
 340                 if (!se->elide)
 341                         ret += 2 + hists__col_len(hists, se->se_width_idx);
 342
 343         if (verbose) /* Addr + origin */
 344                 ret += 3 + BITS_PER_LONG / 4;
 345
 346         return ret;
 347 }