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, const char *fmt, 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, percent); 36 } else 37 ret = hpp__call_print_fn(hpp, print_fn, fmt, 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, 0.0); 64 } else { 65 ret += hpp__call_print_fn(hpp, print_fn, 66 fmt, 0ULL); 67 } 68 } 69 70 if (fmt_percent) { 71 ret += hpp__call_print_fn(hpp, print_fn, fmt, 72 100.0 * period / total); 73 } else { 74 ret += hpp__call_print_fn(hpp, print_fn, fmt, 75 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, 0.0); 90 } else { 91 ret += hpp__call_print_fn(hpp, print_fn, 92 fmt, 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_acc(struct perf_hpp *hpp, struct hist_entry *he, 108 hpp_field_fn get_field, const char *fmt, 109 hpp_snprint_fn print_fn, bool fmt_percent) 110 { 111 if (!symbol_conf.cumulate_callchain) { 112 return snprintf(hpp->buf, hpp->size, "%*s", 113 fmt_percent ? 8 : 12, "N/A"); 114 } 115 116 return __hpp__fmt(hpp, he, get_field, fmt, print_fn, fmt_percent); 117 } 118 119 static int field_cmp(u64 field_a, u64 field_b) 120 { 121 if (field_a > field_b) 122 return 1; 123 if (field_a < field_b) 124 return -1; 125 return 0; 126 } 127 128 static int __hpp__sort(struct hist_entry *a, struct hist_entry *b, 129 hpp_field_fn get_field) 130 { 131 s64 ret; 132 int i, nr_members; 133 struct perf_evsel *evsel; 134 struct hist_entry *pair; 135 u64 *fields_a, *fields_b; 136 137 ret = field_cmp(get_field(a), get_field(b)); 138 if (ret || !symbol_conf.event_group) 139 return ret; 140 141 evsel = hists_to_evsel(a->hists); 142 if (!perf_evsel__is_group_event(evsel)) 143 return ret; 144 145 nr_members = evsel->nr_members; 146 fields_a = calloc(sizeof(*fields_a), nr_members); 147 fields_b = calloc(sizeof(*fields_b), nr_members); 148 149 if (!fields_a || !fields_b) 150 goto out; 151 152 list_for_each_entry(pair, &a->pairs.head, pairs.node) { 153 evsel = hists_to_evsel(pair->hists); 154 fields_a[perf_evsel__group_idx(evsel)] = get_field(pair); 155 } 156 157 list_for_each_entry(pair, &b->pairs.head, pairs.node) { 158 evsel = hists_to_evsel(pair->hists); 159 fields_b[perf_evsel__group_idx(evsel)] = get_field(pair); 160 } 161 162 for (i = 1; i < nr_members; i++) { 163 ret = field_cmp(fields_a[i], fields_b[i]); 164 if (ret) 165 break; 166 } 167 168 out: 169 free(fields_a); 170 free(fields_b); 171 172 return ret; 173 } 174 175 static int __hpp__sort_acc(struct hist_entry *a, struct hist_entry *b, 176 hpp_field_fn get_field) 177 { 178 s64 ret = 0; 179 180 if (symbol_conf.cumulate_callchain) { 181 /* 182 * Put caller above callee when they have equal period. 183 */ 184 ret = field_cmp(get_field(a), get_field(b)); 185 if (ret) 186 return ret; 187 188 ret = b->callchain->max_depth - a->callchain->max_depth; 189 } 190 return ret; 191 } 192 193 #define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ 194 static int hpp__header_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 195 struct perf_hpp *hpp, \ 196 struct perf_evsel *evsel) \ 197 { \ 198 int len = _min_width; \ 199 \ 200 if (symbol_conf.event_group) \ 201 len = max(len, evsel->nr_members * _unit_width); \ 202 \ 203 return scnprintf(hpp->buf, hpp->size, "%*s", len, _str); \ 204 } 205 206 #define __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ 207 static int hpp__width_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 208 struct perf_hpp *hpp __maybe_unused, \ 209 struct perf_evsel *evsel) \ 210 { \ 211 int len = _min_width; \ 212 \ 213 if (symbol_conf.event_group) \ 214 len = max(len, evsel->nr_members * _unit_width); \ 215 \ 216 return len; \ 217 } 218 219 static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) 220 { 221 va_list args; 222 ssize_t ssize = hpp->size; 223 double percent; 224 int ret; 225 226 va_start(args, fmt); 227 percent = va_arg(args, double); 228 ret = value_color_snprintf(hpp->buf, hpp->size, fmt, percent); 229 va_end(args); 230 231 return (ret >= ssize) ? (ssize - 1) : ret; 232 } 233 234 static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) 235 { 236 va_list args; 237 ssize_t ssize = hpp->size; 238 int ret; 239 240 va_start(args, fmt); 241 ret = vsnprintf(hpp->buf, hpp->size, fmt, args); 242 va_end(args); 243 244 return (ret >= ssize) ? (ssize - 1) : ret; 245 } 246 247 #define __HPP_COLOR_PERCENT_FN(_type, _field) \ 248 static u64 he_get_##_field(struct hist_entry *he) \ 249 { \ 250 return he->stat._field; \ 251 } \ 252 \ 253 static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 254 struct perf_hpp *hpp, struct hist_entry *he) \ 255 { \ 256 return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%", \ 257 hpp_color_scnprintf, true); \ 258 } 259 260 #define __HPP_ENTRY_PERCENT_FN(_type, _field) \ 261 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \ 262 struct perf_hpp *hpp, struct hist_entry *he) \ 263 { \ 264 const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%"; \ 265 return __hpp__fmt(hpp, he, he_get_##_field, fmt, \ 266 hpp_entry_scnprintf, true); \ 267 } 268 269 #define __HPP_SORT_FN(_type, _field) \ 270 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \ 271 { \ 272 return __hpp__sort(a, b, he_get_##_field); \ 273 } 274 275 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \ 276 static u64 he_get_acc_##_field(struct hist_entry *he) \ 277 { \ 278 return he->stat_acc->_field; \ 279 } \ 280 \ 281 static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 282 struct perf_hpp *hpp, struct hist_entry *he) \ 283 { \ 284 return __hpp__fmt_acc(hpp, he, he_get_acc_##_field, " %6.2f%%", \ 285 hpp_color_scnprintf, true); \ 286 } 287 288 #define __HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \ 289 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \ 290 struct perf_hpp *hpp, struct hist_entry *he) \ 291 { \ 292 const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%"; \ 293 return __hpp__fmt_acc(hpp, he, he_get_acc_##_field, fmt, \ 294 hpp_entry_scnprintf, true); \ 295 } 296 297 #define __HPP_SORT_ACC_FN(_type, _field) \ 298 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \ 299 { \ 300 return __hpp__sort_acc(a, b, he_get_acc_##_field); \ 301 } 302 303 #define __HPP_ENTRY_RAW_FN(_type, _field) \ 304 static u64 he_get_raw_##_field(struct hist_entry *he) \ 305 { \ 306 return he->stat._field; \ 307 } \ 308 \ 309 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \ 310 struct perf_hpp *hpp, struct hist_entry *he) \ 311 { \ 312 const char *fmt = symbol_conf.field_sep ? " %"PRIu64 : " %11"PRIu64; \ 313 return __hpp__fmt(hpp, he, he_get_raw_##_field, fmt, \ 314 hpp_entry_scnprintf, false); \ 315 } 316 317 #define __HPP_SORT_RAW_FN(_type, _field) \ 318 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \ 319 { \ 320 return __hpp__sort(a, b, he_get_raw_##_field); \ 321 } 322 323 324 #define HPP_PERCENT_FNS(_type, _str, _field, _min_width, _unit_width) \ 325 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ 326 __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ 327 __HPP_COLOR_PERCENT_FN(_type, _field) \ 328 __HPP_ENTRY_PERCENT_FN(_type, _field) \ 329 __HPP_SORT_FN(_type, _field) 330 331 #define HPP_PERCENT_ACC_FNS(_type, _str, _field, _min_width, _unit_width)\ 332 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ 333 __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ 334 __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \ 335 __HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \ 336 __HPP_SORT_ACC_FN(_type, _field) 337 338 #define HPP_RAW_FNS(_type, _str, _field, _min_width, _unit_width) \ 339 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ 340 __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ 341 __HPP_ENTRY_RAW_FN(_type, _field) \ 342 __HPP_SORT_RAW_FN(_type, _field) 343 344 __HPP_HEADER_FN(overhead_self, "Self", 8, 8) 345 346 HPP_PERCENT_FNS(overhead, "Overhead", period, 8, 8) 347 HPP_PERCENT_FNS(overhead_sys, "sys", period_sys, 8, 8) 348 HPP_PERCENT_FNS(overhead_us, "usr", period_us, 8, 8) 349 HPP_PERCENT_FNS(overhead_guest_sys, "guest sys", period_guest_sys, 9, 8) 350 HPP_PERCENT_FNS(overhead_guest_us, "guest usr", period_guest_us, 9, 8) 351 HPP_PERCENT_ACC_FNS(overhead_acc, "Children", period, 8, 8) 352 353 HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12) 354 HPP_RAW_FNS(period, "Period", period, 12, 12) 355 356 static int64_t hpp__nop_cmp(struct hist_entry *a __maybe_unused, 357 struct hist_entry *b __maybe_unused) 358 { 359 return 0; 360 } 361 362 #define HPP__COLOR_PRINT_FNS(_name) \ 363 { \ 364 .header = hpp__header_ ## _name, \ 365 .width = hpp__width_ ## _name, \ 366 .color = hpp__color_ ## _name, \ 367 .entry = hpp__entry_ ## _name, \ 368 .cmp = hpp__nop_cmp, \ 369 .collapse = hpp__nop_cmp, \ 370 .sort = hpp__sort_ ## _name, \ 371 } 372 373 #define HPP__COLOR_ACC_PRINT_FNS(_name) \ 374 { \ 375 .header = hpp__header_ ## _name, \ 376 .width = hpp__width_ ## _name, \ 377 .color = hpp__color_ ## _name, \ 378 .entry = hpp__entry_ ## _name, \ 379 .cmp = hpp__nop_cmp, \ 380 .collapse = hpp__nop_cmp, \ 381 .sort = hpp__sort_ ## _name, \ 382 } 383 384 #define HPP__PRINT_FNS(_name) \ 385 { \ 386 .header = hpp__header_ ## _name, \ 387 .width = hpp__width_ ## _name, \ 388 .entry = hpp__entry_ ## _name, \ 389 .cmp = hpp__nop_cmp, \ 390 .collapse = hpp__nop_cmp, \ 391 .sort = hpp__sort_ ## _name, \ 392 } 393 394 struct perf_hpp_fmt perf_hpp__format[] = { 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__COLOR_ACC_PRINT_FNS(overhead_acc), 401 HPP__PRINT_FNS(samples), 402 HPP__PRINT_FNS(period) 403 }; 404 405 LIST_HEAD(perf_hpp__list); 406 LIST_HEAD(perf_hpp__sort_list); 407 408 409 #undef HPP__COLOR_PRINT_FNS 410 #undef HPP__COLOR_ACC_PRINT_FNS 411 #undef HPP__PRINT_FNS 412 413 #undef HPP_PERCENT_FNS 414 #undef HPP_PERCENT_ACC_FNS 415 #undef HPP_RAW_FNS 416 417 #undef __HPP_HEADER_FN 418 #undef __HPP_WIDTH_FN 419 #undef __HPP_COLOR_PERCENT_FN 420 #undef __HPP_ENTRY_PERCENT_FN 421 #undef __HPP_COLOR_ACC_PERCENT_FN 422 #undef __HPP_ENTRY_ACC_PERCENT_FN 423 #undef __HPP_ENTRY_RAW_FN 424 #undef __HPP_SORT_FN 425 #undef __HPP_SORT_ACC_FN 426 #undef __HPP_SORT_RAW_FN 427 428 429 void perf_hpp__init(void) 430 { 431 struct list_head *list; 432 int i; 433 434 for (i = 0; i < PERF_HPP__MAX_INDEX; i++) { 435 struct perf_hpp_fmt *fmt = &perf_hpp__format[i]; 436 437 INIT_LIST_HEAD(&fmt->list); 438 439 /* sort_list may be linked by setup_sorting() */ 440 if (fmt->sort_list.next == NULL) 441 INIT_LIST_HEAD(&fmt->sort_list); 442 } 443 444 /* 445 * If user specified field order, no need to setup default fields. 446 */ 447 if (field_order) 448 return; 449 450 if (symbol_conf.cumulate_callchain) { 451 perf_hpp__column_enable(PERF_HPP__OVERHEAD_ACC); 452 453 perf_hpp__format[PERF_HPP__OVERHEAD].header = 454 hpp__header_overhead_self; 455 } 456 457 perf_hpp__column_enable(PERF_HPP__OVERHEAD); 458 459 if (symbol_conf.show_cpu_utilization) { 460 perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS); 461 perf_hpp__column_enable(PERF_HPP__OVERHEAD_US); 462 463 if (perf_guest) { 464 perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS); 465 perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US); 466 } 467 } 468 469 if (symbol_conf.show_nr_samples) 470 perf_hpp__column_enable(PERF_HPP__SAMPLES); 471 472 if (symbol_conf.show_total_period) 473 perf_hpp__column_enable(PERF_HPP__PERIOD); 474 475 /* prepend overhead field for backward compatiblity. */ 476 list = &perf_hpp__format[PERF_HPP__OVERHEAD].sort_list; 477 if (list_empty(list)) 478 list_add(list, &perf_hpp__sort_list); 479 480 if (symbol_conf.cumulate_callchain) { 481 list = &perf_hpp__format[PERF_HPP__OVERHEAD_ACC].sort_list; 482 if (list_empty(list)) 483 list_add(list, &perf_hpp__sort_list); 484 } 485 } 486 487 void perf_hpp__column_register(struct perf_hpp_fmt *format) 488 { 489 list_add_tail(&format->list, &perf_hpp__list); 490 } 491 492 void perf_hpp__column_unregister(struct perf_hpp_fmt *format) 493 { 494 list_del(&format->list); 495 } 496 497 void perf_hpp__register_sort_field(struct perf_hpp_fmt *format) 498 { 499 list_add_tail(&format->sort_list, &perf_hpp__sort_list); 500 } 501 502 void perf_hpp__column_enable(unsigned col) 503 { 504 BUG_ON(col >= PERF_HPP__MAX_INDEX); 505 perf_hpp__column_register(&perf_hpp__format[col]); 506 } 507 508 void perf_hpp__column_disable(unsigned col) 509 { 510 BUG_ON(col >= PERF_HPP__MAX_INDEX); 511 perf_hpp__column_unregister(&perf_hpp__format[col]); 512 } 513 514 void perf_hpp__cancel_cumulate(void) 515 { 516 if (field_order) 517 return; 518 519 perf_hpp__column_disable(PERF_HPP__OVERHEAD_ACC); 520 perf_hpp__format[PERF_HPP__OVERHEAD].header = hpp__header_overhead; 521 } 522 523 void perf_hpp__setup_output_field(void) 524 { 525 struct perf_hpp_fmt *fmt; 526 527 /* append sort keys to output field */ 528 perf_hpp__for_each_sort_list(fmt) { 529 if (!list_empty(&fmt->list)) 530 continue; 531 532 /* 533 * sort entry fields are dynamically created, 534 * so they can share a same sort key even though 535 * the list is empty. 536 */ 537 if (perf_hpp__is_sort_entry(fmt)) { 538 struct perf_hpp_fmt *pos; 539 540 perf_hpp__for_each_format(pos) { 541 if (perf_hpp__same_sort_entry(pos, fmt)) 542 goto next; 543 } 544 } 545 546 perf_hpp__column_register(fmt); 547 next: 548 continue; 549 } 550 } 551 552 void perf_hpp__append_sort_keys(void) 553 { 554 struct perf_hpp_fmt *fmt; 555 556 /* append output fields to sort keys */ 557 perf_hpp__for_each_format(fmt) { 558 if (!list_empty(&fmt->sort_list)) 559 continue; 560 561 /* 562 * sort entry fields are dynamically created, 563 * so they can share a same sort key even though 564 * the list is empty. 565 */ 566 if (perf_hpp__is_sort_entry(fmt)) { 567 struct perf_hpp_fmt *pos; 568 569 perf_hpp__for_each_sort_list(pos) { 570 if (perf_hpp__same_sort_entry(pos, fmt)) 571 goto next; 572 } 573 } 574 575 perf_hpp__register_sort_field(fmt); 576 next: 577 continue; 578 } 579 } 580 581 void perf_hpp__reset_output_field(void) 582 { 583 struct perf_hpp_fmt *fmt, *tmp; 584 585 /* reset output fields */ 586 perf_hpp__for_each_format_safe(fmt, tmp) { 587 list_del_init(&fmt->list); 588 list_del_init(&fmt->sort_list); 589 } 590 591 /* reset sort keys */ 592 perf_hpp__for_each_sort_list_safe(fmt, tmp) { 593 list_del_init(&fmt->list); 594 list_del_init(&fmt->sort_list); 595 } 596 } 597 598 /* 599 * See hists__fprintf to match the column widths 600 */ 601 unsigned int hists__sort_list_width(struct hists *hists) 602 { 603 struct perf_hpp_fmt *fmt; 604 int ret = 0; 605 bool first = true; 606 struct perf_hpp dummy_hpp; 607 608 perf_hpp__for_each_format(fmt) { 609 if (perf_hpp__should_skip(fmt)) 610 continue; 611 612 if (first) 613 first = false; 614 else 615 ret += 2; 616 617 ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists)); 618 } 619 620 if (verbose && sort__has_sym) /* Addr + origin */ 621 ret += 3 + BITS_PER_LONG / 4; 622 623 return ret; 624 } 625