tools/perf/ui/hist.c

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