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_displ(struct perf_hpp *hpp)
 355 {
 356         return scnprintf(hpp->buf, hpp->size, "Displ.");
 357 }
 358
 359 static int hpp__width_displ(struct perf_hpp *hpp __maybe_unused)
 360 {
 361         return 6;
 362 }
 363
 364 static int hpp__entry_displ(struct perf_hpp *hpp,
 365                             struct hist_entry *he)
 366 {
 367         struct hist_entry *pair = hist_entry__next_pair(he);
 368         long displacement = pair ? pair->position - he->position : 0;
 369         const char *fmt = symbol_conf.field_sep ? "%s" : "%6.6s";
 370         char buf[32] = " ";
 371
 372         if (displacement)
 373                 scnprintf(buf, sizeof(buf), "%+4ld", displacement);
 374
 375         return scnprintf(hpp->buf, hpp->size, fmt, buf);
 376 }
 377
 378 static int hpp__header_formula(struct perf_hpp *hpp)
 379 {
 380         const char *fmt = symbol_conf.field_sep ? "%s" : "%70s";
 381
 382         return scnprintf(hpp->buf, hpp->size, fmt, "Formula");
 383 }
 384
 385 static int hpp__width_formula(struct perf_hpp *hpp __maybe_unused)
 386 {
 387         return 70;
 388 }
 389
 390 static int hpp__entry_formula(struct perf_hpp *hpp, struct hist_entry *he)
 391 {
 392         const char *fmt = symbol_conf.field_sep ? "%s" : "%-70s";
 393         char buf[96] = " ";
 394
 395         perf_diff__formula(buf, sizeof(buf), he);
 396         return scnprintf(hpp->buf, hpp->size, fmt, buf);
 397 }
 398
 399 #define HPP__COLOR_PRINT_FNS(_name)                     \
 400         {                                               \
 401                 .header = hpp__header_ ## _name,        \
 402                 .width  = hpp__width_ ## _name,         \
 403                 .color  = hpp__color_ ## _name,         \
 404                 .entry  = hpp__entry_ ## _name          \
 405         }
 406
 407 #define HPP__PRINT_FNS(_name)                           \
 408         {                                               \
 409                 .header = hpp__header_ ## _name,        \
 410                 .width  = hpp__width_ ## _name,         \
 411                 .entry  = hpp__entry_ ## _name          \
 412         }
 413
 414 struct perf_hpp_fmt perf_hpp__format[] = {
 415         HPP__COLOR_PRINT_FNS(baseline),
 416         HPP__COLOR_PRINT_FNS(overhead),
 417         HPP__COLOR_PRINT_FNS(overhead_sys),
 418         HPP__COLOR_PRINT_FNS(overhead_us),
 419         HPP__COLOR_PRINT_FNS(overhead_guest_sys),
 420         HPP__COLOR_PRINT_FNS(overhead_guest_us),
 421         HPP__PRINT_FNS(samples),
 422         HPP__PRINT_FNS(period),
 423         HPP__PRINT_FNS(period_baseline),
 424         HPP__PRINT_FNS(delta),
 425         HPP__PRINT_FNS(ratio),
 426         HPP__PRINT_FNS(wdiff),
 427         HPP__PRINT_FNS(displ),
 428         HPP__PRINT_FNS(formula)
 429 };
 430
 431 LIST_HEAD(perf_hpp__list);
 432
 433 #undef HPP__COLOR_PRINT_FNS
 434 #undef HPP__PRINT_FNS
 435
 436 void perf_hpp__init(void)
 437 {
 438         if (symbol_conf.show_cpu_utilization) {
 439                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
 440                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);
 441
 442                 if (perf_guest) {
 443                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS);
 444                         perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US);
 445                 }
 446         }
 447
 448         if (symbol_conf.show_nr_samples)
 449                 perf_hpp__column_enable(PERF_HPP__SAMPLES);
 450
 451         if (symbol_conf.show_total_period)
 452                 perf_hpp__column_enable(PERF_HPP__PERIOD);
 453 }
 454
 455 void perf_hpp__column_register(struct perf_hpp_fmt *format)
 456 {
 457         list_add_tail(&format->list, &perf_hpp__list);
 458 }
 459
 460 void perf_hpp__column_enable(unsigned col)
 461 {
 462         BUG_ON(col >= PERF_HPP__MAX_INDEX);
 463         perf_hpp__column_register(&perf_hpp__format[col]);
 464 }
 465
 466 static inline void advance_hpp(struct perf_hpp *hpp, int inc)
 467 {
 468         hpp->buf  += inc;
 469         hpp->size -= inc;
 470 }
 471
 472 int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he,
 473                                 bool color)
 474 {
 475         const char *sep = symbol_conf.field_sep;
 476         struct perf_hpp_fmt *fmt;
 477         char *start = hpp->buf;
 478         int ret;
 479         bool first = true;
 480
 481         if (symbol_conf.exclude_other && !he->parent)
 482                 return 0;
 483
 484         perf_hpp__for_each_format(fmt) {
 485                 /*
 486                  * If there's no field_sep, we still need
 487                  * to display initial '  '.
 488                  */
 489                 if (!sep || !first) {
 490                         ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
 491                         advance_hpp(hpp, ret);
 492                 } else
 493                         first = false;
 494
 495                 if (color && fmt->color)
 496                         ret = fmt->color(hpp, he);
 497                 else
 498                         ret = fmt->entry(hpp, he);
 499
 500                 advance_hpp(hpp, ret);
 501         }
 502
 503         return hpp->buf - start;
 504 }
 505
 506 int hist_entry__sort_snprintf(struct hist_entry *he, char *s, size_t size,
 507                               struct hists *hists)
 508 {
 509         const char *sep = symbol_conf.field_sep;
 510         struct sort_entry *se;
 511         int ret = 0;
 512
 513         list_for_each_entry(se, &hist_entry__sort_list, list) {
 514                 if (se->elide)
 515                         continue;
 516
 517                 ret += scnprintf(s + ret, size - ret, "%s", sep ?: "  ");
 518                 ret += se->se_snprintf(he, s + ret, size - ret,
 519                                        hists__col_len(hists, se->se_width_idx));
 520         }
 521
 522         return ret;
 523 }
 524
 525 /*
 526  * See hists__fprintf to match the column widths
 527  */
 528 unsigned int hists__sort_list_width(struct hists *hists)
 529 {
 530         struct perf_hpp_fmt *fmt;
 531         struct sort_entry *se;
 532         int i = 0, ret = 0;
 533
 534         perf_hpp__for_each_format(fmt) {
 535                 if (i)
 536                         ret += 2;
 537
 538                 ret += fmt->width(NULL);
 539         }
 540
 541         list_for_each_entry(se, &hist_entry__sort_list, list)
 542                 if (!se->elide)
 543                         ret += 2 + hists__col_len(hists, se->se_width_idx);
 544
 545         if (verbose) /* Addr + origin */
 546                 ret += 3 + BITS_PER_LONG / 4;
 547
 548         return ret;
 549 }