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 #include "../util/evlist.h" 9 10 /* hist period print (hpp) functions */ 11 12 #define hpp__call_print_fn(hpp, fn, fmt, ...) \ 13 ({ \ 14 int __ret = fn(hpp, fmt, ##__VA_ARGS__); \ 15 advance_hpp(hpp, __ret); \ 16 __ret; \ 17 }) 18 19 static int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he, 20 hpp_field_fn get_field, const char *fmt, int len, 21 hpp_snprint_fn print_fn, bool fmt_percent) 22 { 23 int ret; 24 struct hists *hists = he->hists; 25 struct perf_evsel *evsel = hists_to_evsel(hists); 26 char *buf = hpp->buf; 27 size_t size = hpp->size; 28 29 if (fmt_percent) { 30 double percent = 0.0; 31 u64 total = hists__total_period(hists); 32 33 if (total) 34 percent = 100.0 * get_field(he) / total; 35 36 ret = hpp__call_print_fn(hpp, print_fn, fmt, len, percent); 37 } else 38 ret = hpp__call_print_fn(hpp, print_fn, fmt, len, get_field(he)); 39 40 if (perf_evsel__is_group_event(evsel)) { 41 int prev_idx, idx_delta; 42 struct hist_entry *pair; 43 int nr_members = evsel->nr_members; 44 45 prev_idx = perf_evsel__group_idx(evsel); 46 47 list_for_each_entry(pair, &he->pairs.head, pairs.node) { 48 u64 period = get_field(pair); 49 u64 total = hists__total_period(pair->hists); 50 51 if (!total) 52 continue; 53 54 evsel = hists_to_evsel(pair->hists); 55 idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1; 56 57 while (idx_delta--) { 58 /* 59 * zero-fill group members in the middle which 60 * have no sample 61 */ 62 if (fmt_percent) { 63 ret += hpp__call_print_fn(hpp, print_fn, 64 fmt, len, 0.0); 65 } else { 66 ret += hpp__call_print_fn(hpp, print_fn, 67 fmt, len, 0ULL); 68 } 69 } 70 71 if (fmt_percent) { 72 ret += hpp__call_print_fn(hpp, print_fn, fmt, len, 73 100.0 * period / total); 74 } else { 75 ret += hpp__call_print_fn(hpp, print_fn, fmt, 76 len, period); 77 } 78 79 prev_idx = perf_evsel__group_idx(evsel); 80 } 81 82 idx_delta = nr_members - prev_idx - 1; 83 84 while (idx_delta--) { 85 /* 86 * zero-fill group members at last which have no sample 87 */ 88 if (fmt_percent) { 89 ret += hpp__call_print_fn(hpp, print_fn, 90 fmt, len, 0.0); 91 } else { 92 ret += hpp__call_print_fn(hpp, print_fn, 93 fmt, len, 0ULL); 94 } 95 } 96 } 97 98 /* 99 * Restore original buf and size as it's where caller expects 100 * the result will be saved. 101 */ 102 hpp->buf = buf; 103 hpp->size = size; 104 105 return ret; 106 } 107 108 int hpp__fmt(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 109 struct hist_entry *he, hpp_field_fn get_field, 110 const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent) 111 { 112 int len = fmt->user_len ?: fmt->len; 113 114 if (symbol_conf.field_sep) { 115 return __hpp__fmt(hpp, he, get_field, fmtstr, 1, 116 print_fn, fmt_percent); 117 } 118 119 if (fmt_percent) 120 len -= 2; /* 2 for a space and a % sign */ 121 else 122 len -= 1; 123 124 return __hpp__fmt(hpp, he, get_field, fmtstr, len, print_fn, fmt_percent); 125 } 126 127 int hpp__fmt_acc(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 128 struct hist_entry *he, hpp_field_fn get_field, 129 const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent) 130 { 131 if (!symbol_conf.cumulate_callchain) { 132 int len = fmt->user_len ?: fmt->len; 133 return snprintf(hpp->buf, hpp->size, " %*s", len - 1, "N/A"); 134 } 135 136 return hpp__fmt(fmt, hpp, he, get_field, fmtstr, print_fn, fmt_percent); 137 } 138 139 static int field_cmp(u64 field_a, u64 field_b) 140 { 141 if (field_a > field_b) 142 return 1; 143 if (field_a < field_b) 144 return -1; 145 return 0; 146 } 147 148 static int __hpp__sort(struct hist_entry *a, struct hist_entry *b, 149 hpp_field_fn get_field) 150 { 151 s64 ret; 152 int i, nr_members; 153 struct perf_evsel *evsel; 154 struct hist_entry *pair; 155 u64 *fields_a, *fields_b; 156 157 ret = field_cmp(get_field(a), get_field(b)); 158 if (ret || !symbol_conf.event_group) 159 return ret; 160 161 evsel = hists_to_evsel(a->hists); 162 if (!perf_evsel__is_group_event(evsel)) 163 return ret; 164 165 nr_members = evsel->nr_members; 166 fields_a = calloc(nr_members, sizeof(*fields_a)); 167 fields_b = calloc(nr_members, sizeof(*fields_b)); 168 169 if (!fields_a || !fields_b) 170 goto out; 171 172 list_for_each_entry(pair, &a->pairs.head, pairs.node) { 173 evsel = hists_to_evsel(pair->hists); 174 fields_a[perf_evsel__group_idx(evsel)] = get_field(pair); 175 } 176 177 list_for_each_entry(pair, &b->pairs.head, pairs.node) { 178 evsel = hists_to_evsel(pair->hists); 179 fields_b[perf_evsel__group_idx(evsel)] = get_field(pair); 180 } 181 182 for (i = 1; i < nr_members; i++) { 183 ret = field_cmp(fields_a[i], fields_b[i]); 184 if (ret) 185 break; 186 } 187 188 out: 189 free(fields_a); 190 free(fields_b); 191 192 return ret; 193 } 194 195 static int __hpp__sort_acc(struct hist_entry *a, struct hist_entry *b, 196 hpp_field_fn get_field) 197 { 198 s64 ret = 0; 199 200 if (symbol_conf.cumulate_callchain) { 201 /* 202 * Put caller above callee when they have equal period. 203 */ 204 ret = field_cmp(get_field(a), get_field(b)); 205 if (ret) 206 return ret; 207 208 if (a->thread != b->thread || !symbol_conf.use_callchain) 209 return 0; 210 211 ret = b->callchain->max_depth - a->callchain->max_depth; 212 } 213 return ret; 214 } 215 216 static int hpp__width_fn(struct perf_hpp_fmt *fmt, 217 struct perf_hpp *hpp __maybe_unused, 218 struct hists *hists) 219 { 220 int len = fmt->user_len ?: fmt->len; 221 struct perf_evsel *evsel = hists_to_evsel(hists); 222 223 if (symbol_conf.event_group) 224 len = max(len, evsel->nr_members * fmt->len); 225 226 if (len < (int)strlen(fmt->name)) 227 len = strlen(fmt->name); 228 229 return len; 230 } 231 232 static int hpp__header_fn(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 233 struct hists *hists) 234 { 235 int len = hpp__width_fn(fmt, hpp, hists); 236 return scnprintf(hpp->buf, hpp->size, "%*s", len, fmt->name); 237 } 238 239 static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) 240 { 241 va_list args; 242 ssize_t ssize = hpp->size; 243 double percent; 244 int ret, len; 245 246 va_start(args, fmt); 247 len = va_arg(args, int); 248 percent = va_arg(args, double); 249 ret = percent_color_len_snprintf(hpp->buf, hpp->size, fmt, len, percent); 250 va_end(args); 251 252 return (ret >= ssize) ? (ssize - 1) : ret; 253 } 254 255 static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) 256 { 257 va_list args; 258 ssize_t ssize = hpp->size; 259 int ret; 260 261 va_start(args, fmt); 262 ret = vsnprintf(hpp->buf, hpp->size, fmt, args); 263 va_end(args); 264 265 return (ret >= ssize) ? (ssize - 1) : ret; 266 } 267 268 #define __HPP_COLOR_PERCENT_FN(_type, _field) \ 269 static u64 he_get_##_field(struct hist_entry *he) \ 270 { \ 271 return he->stat._field; \ 272 } \ 273 \ 274 static int hpp__color_##_type(struct perf_hpp_fmt *fmt, \ 275 struct perf_hpp *hpp, struct hist_entry *he) \ 276 { \ 277 return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%", \ 278 hpp_color_scnprintf, true); \ 279 } 280 281 #define __HPP_ENTRY_PERCENT_FN(_type, _field) \ 282 static int hpp__entry_##_type(struct perf_hpp_fmt *fmt, \ 283 struct perf_hpp *hpp, struct hist_entry *he) \ 284 { \ 285 return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%", \ 286 hpp_entry_scnprintf, true); \ 287 } 288 289 #define __HPP_SORT_FN(_type, _field) \ 290 static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 291 struct hist_entry *a, struct hist_entry *b) \ 292 { \ 293 return __hpp__sort(a, b, he_get_##_field); \ 294 } 295 296 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \ 297 static u64 he_get_acc_##_field(struct hist_entry *he) \ 298 { \ 299 return he->stat_acc->_field; \ 300 } \ 301 \ 302 static int hpp__color_##_type(struct perf_hpp_fmt *fmt, \ 303 struct perf_hpp *hpp, struct hist_entry *he) \ 304 { \ 305 return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%", \ 306 hpp_color_scnprintf, true); \ 307 } 308 309 #define __HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \ 310 static int hpp__entry_##_type(struct perf_hpp_fmt *fmt, \ 311 struct perf_hpp *hpp, struct hist_entry *he) \ 312 { \ 313 return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%", \ 314 hpp_entry_scnprintf, true); \ 315 } 316 317 #define __HPP_SORT_ACC_FN(_type, _field) \ 318 static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 319 struct hist_entry *a, struct hist_entry *b) \ 320 { \ 321 return __hpp__sort_acc(a, b, he_get_acc_##_field); \ 322 } 323 324 #define __HPP_ENTRY_RAW_FN(_type, _field) \ 325 static u64 he_get_raw_##_field(struct hist_entry *he) \ 326 { \ 327 return he->stat._field; \ 328 } \ 329 \ 330 static int hpp__entry_##_type(struct perf_hpp_fmt *fmt, \ 331 struct perf_hpp *hpp, struct hist_entry *he) \ 332 { \ 333 return hpp__fmt(fmt, hpp, he, he_get_raw_##_field, " %*"PRIu64, \ 334 hpp_entry_scnprintf, false); \ 335 } 336 337 #define __HPP_SORT_RAW_FN(_type, _field) \ 338 static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 339 struct hist_entry *a, struct hist_entry *b) \ 340 { \ 341 return __hpp__sort(a, b, he_get_raw_##_field); \ 342 } 343 344 345 #define HPP_PERCENT_FNS(_type, _field) \ 346 __HPP_COLOR_PERCENT_FN(_type, _field) \ 347 __HPP_ENTRY_PERCENT_FN(_type, _field) \ 348 __HPP_SORT_FN(_type, _field) 349 350 #define HPP_PERCENT_ACC_FNS(_type, _field) \ 351 __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \ 352 __HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \ 353 __HPP_SORT_ACC_FN(_type, _field) 354 355 #define HPP_RAW_FNS(_type, _field) \ 356 __HPP_ENTRY_RAW_FN(_type, _field) \ 357 __HPP_SORT_RAW_FN(_type, _field) 358 359 HPP_PERCENT_FNS(overhead, period) 360 HPP_PERCENT_FNS(overhead_sys, period_sys) 361 HPP_PERCENT_FNS(overhead_us, period_us) 362 HPP_PERCENT_FNS(overhead_guest_sys, period_guest_sys) 363 HPP_PERCENT_FNS(overhead_guest_us, period_guest_us) 364 HPP_PERCENT_ACC_FNS(overhead_acc, period) 365 366 HPP_RAW_FNS(samples, nr_events) 367 HPP_RAW_FNS(period, period) 368 369 static int64_t hpp__nop_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 370 struct hist_entry *a __maybe_unused, 371 struct hist_entry *b __maybe_unused) 372 { 373 return 0; 374 } 375 376 static bool perf_hpp__is_hpp_entry(struct perf_hpp_fmt *a) 377 { 378 return a->header == hpp__header_fn; 379 } 380 381 static bool hpp__equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b) 382 { 383 if (!perf_hpp__is_hpp_entry(a) || !perf_hpp__is_hpp_entry(b)) 384 return false; 385 386 return a->idx == b->idx; 387 } 388 389 #define HPP__COLOR_PRINT_FNS(_name, _fn, _idx) \ 390 { \ 391 .name = _name, \ 392 .header = hpp__header_fn, \ 393 .width = hpp__width_fn, \ 394 .color = hpp__color_ ## _fn, \ 395 .entry = hpp__entry_ ## _fn, \ 396 .cmp = hpp__nop_cmp, \ 397 .collapse = hpp__nop_cmp, \ 398 .sort = hpp__sort_ ## _fn, \ 399 .idx = PERF_HPP__ ## _idx, \ 400 .equal = hpp__equal, \ 401 } 402 403 #define HPP__COLOR_ACC_PRINT_FNS(_name, _fn, _idx) \ 404 { \ 405 .name = _name, \ 406 .header = hpp__header_fn, \ 407 .width = hpp__width_fn, \ 408 .color = hpp__color_ ## _fn, \ 409 .entry = hpp__entry_ ## _fn, \ 410 .cmp = hpp__nop_cmp, \ 411 .collapse = hpp__nop_cmp, \ 412 .sort = hpp__sort_ ## _fn, \ 413 .idx = PERF_HPP__ ## _idx, \ 414 .equal = hpp__equal, \ 415 } 416 417 #define HPP__PRINT_FNS(_name, _fn, _idx) \ 418 { \ 419 .name = _name, \ 420 .header = hpp__header_fn, \ 421 .width = hpp__width_fn, \ 422 .entry = hpp__entry_ ## _fn, \ 423 .cmp = hpp__nop_cmp, \ 424 .collapse = hpp__nop_cmp, \ 425 .sort = hpp__sort_ ## _fn, \ 426 .idx = PERF_HPP__ ## _idx, \ 427 .equal = hpp__equal, \ 428 } 429 430 struct perf_hpp_fmt perf_hpp__format[] = { 431 HPP__COLOR_PRINT_FNS("Overhead", overhead, OVERHEAD), 432 HPP__COLOR_PRINT_FNS("sys", overhead_sys, OVERHEAD_SYS), 433 HPP__COLOR_PRINT_FNS("usr", overhead_us, OVERHEAD_US), 434 HPP__COLOR_PRINT_FNS("guest sys", overhead_guest_sys, OVERHEAD_GUEST_SYS), 435 HPP__COLOR_PRINT_FNS("guest usr", overhead_guest_us, OVERHEAD_GUEST_US), 436 HPP__COLOR_ACC_PRINT_FNS("Children", overhead_acc, OVERHEAD_ACC), 437 HPP__PRINT_FNS("Samples", samples, SAMPLES), 438 HPP__PRINT_FNS("Period", period, PERIOD) 439 }; 440 441 struct perf_hpp_list perf_hpp_list = { 442 .fields = LIST_HEAD_INIT(perf_hpp_list.fields), 443 .sorts = LIST_HEAD_INIT(perf_hpp_list.sorts), 444 }; 445 446 #undef HPP__COLOR_PRINT_FNS 447 #undef HPP__COLOR_ACC_PRINT_FNS 448 #undef HPP__PRINT_FNS 449 450 #undef HPP_PERCENT_FNS 451 #undef HPP_PERCENT_ACC_FNS 452 #undef HPP_RAW_FNS 453 454 #undef __HPP_HEADER_FN 455 #undef __HPP_WIDTH_FN 456 #undef __HPP_COLOR_PERCENT_FN 457 #undef __HPP_ENTRY_PERCENT_FN 458 #undef __HPP_COLOR_ACC_PERCENT_FN 459 #undef __HPP_ENTRY_ACC_PERCENT_FN 460 #undef __HPP_ENTRY_RAW_FN 461 #undef __HPP_SORT_FN 462 #undef __HPP_SORT_ACC_FN 463 #undef __HPP_SORT_RAW_FN 464 465 466 void perf_hpp__init(void) 467 { 468 int i; 469 470 for (i = 0; i < PERF_HPP__MAX_INDEX; i++) { 471 struct perf_hpp_fmt *fmt = &perf_hpp__format[i]; 472 473 INIT_LIST_HEAD(&fmt->list); 474 475 /* sort_list may be linked by setup_sorting() */ 476 if (fmt->sort_list.next == NULL) 477 INIT_LIST_HEAD(&fmt->sort_list); 478 } 479 480 /* 481 * If user specified field order, no need to setup default fields. 482 */ 483 if (is_strict_order(field_order)) 484 return; 485 486 if (symbol_conf.cumulate_callchain) { 487 hpp_dimension__add_output(PERF_HPP__OVERHEAD_ACC); 488 perf_hpp__format[PERF_HPP__OVERHEAD].name = "Self"; 489 } 490 491 hpp_dimension__add_output(PERF_HPP__OVERHEAD); 492 493 if (symbol_conf.show_cpu_utilization) { 494 hpp_dimension__add_output(PERF_HPP__OVERHEAD_SYS); 495 hpp_dimension__add_output(PERF_HPP__OVERHEAD_US); 496 497 if (perf_guest) { 498 hpp_dimension__add_output(PERF_HPP__OVERHEAD_GUEST_SYS); 499 hpp_dimension__add_output(PERF_HPP__OVERHEAD_GUEST_US); 500 } 501 } 502 503 if (symbol_conf.show_nr_samples) 504 hpp_dimension__add_output(PERF_HPP__SAMPLES); 505 506 if (symbol_conf.show_total_period) 507 hpp_dimension__add_output(PERF_HPP__PERIOD); 508 } 509 510 void perf_hpp_list__column_register(struct perf_hpp_list *list, 511 struct perf_hpp_fmt *format) 512 { 513 list_add_tail(&format->list, &list->fields); 514 } 515 516 void perf_hpp_list__register_sort_field(struct perf_hpp_list *list, 517 struct perf_hpp_fmt *format) 518 { 519 list_add_tail(&format->sort_list, &list->sorts); 520 } 521 522 void perf_hpp__column_unregister(struct perf_hpp_fmt *format) 523 { 524 list_del(&format->list); 525 } 526 527 void perf_hpp__cancel_cumulate(void) 528 { 529 struct perf_hpp_fmt *fmt, *acc, *ovh, *tmp; 530 531 if (is_strict_order(field_order)) 532 return; 533 534 ovh = &perf_hpp__format[PERF_HPP__OVERHEAD]; 535 acc = &perf_hpp__format[PERF_HPP__OVERHEAD_ACC]; 536 537 perf_hpp_list__for_each_format_safe(&perf_hpp_list, fmt, tmp) { 538 if (acc->equal(acc, fmt)) { 539 perf_hpp__column_unregister(fmt); 540 continue; 541 } 542 543 if (ovh->equal(ovh, fmt)) 544 fmt->name = "Overhead"; 545 } 546 } 547 548 static bool fmt_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b) 549 { 550 return a->equal && a->equal(a, b); 551 } 552 553 void perf_hpp__setup_output_field(struct perf_hpp_list *list) 554 { 555 struct perf_hpp_fmt *fmt; 556 557 /* append sort keys to output field */ 558 perf_hpp_list__for_each_sort_list(list, fmt) { 559 struct perf_hpp_fmt *pos; 560 561 perf_hpp_list__for_each_format(list, pos) { 562 if (fmt_equal(fmt, pos)) 563 goto next; 564 } 565 566 perf_hpp__column_register(fmt); 567 next: 568 continue; 569 } 570 } 571 572 void perf_hpp__append_sort_keys(struct perf_hpp_list *list) 573 { 574 struct perf_hpp_fmt *fmt; 575 576 /* append output fields to sort keys */ 577 perf_hpp_list__for_each_format(list, fmt) { 578 struct perf_hpp_fmt *pos; 579 580 perf_hpp_list__for_each_sort_list(list, pos) { 581 if (fmt_equal(fmt, pos)) 582 goto next; 583 } 584 585 perf_hpp__register_sort_field(fmt); 586 next: 587 continue; 588 } 589 } 590 591 592 static void fmt_free(struct perf_hpp_fmt *fmt) 593 { 594 if (fmt->free) 595 fmt->free(fmt); 596 } 597 598 void perf_hpp__reset_output_field(struct perf_hpp_list *list) 599 { 600 struct perf_hpp_fmt *fmt, *tmp; 601 602 /* reset output fields */ 603 perf_hpp_list__for_each_format_safe(list, fmt, tmp) { 604 list_del_init(&fmt->list); 605 list_del_init(&fmt->sort_list); 606 fmt_free(fmt); 607 } 608 609 /* reset sort keys */ 610 perf_hpp_list__for_each_sort_list_safe(list, fmt, tmp) { 611 list_del_init(&fmt->list); 612 list_del_init(&fmt->sort_list); 613 fmt_free(fmt); 614 } 615 } 616 617 /* 618 * See hists__fprintf to match the column widths 619 */ 620 unsigned int hists__sort_list_width(struct hists *hists) 621 { 622 struct perf_hpp_fmt *fmt; 623 int ret = 0; 624 bool first = true; 625 struct perf_hpp dummy_hpp; 626 627 hists__for_each_format(hists, fmt) { 628 if (perf_hpp__should_skip(fmt, hists)) 629 continue; 630 631 if (first) 632 first = false; 633 else 634 ret += 2; 635 636 ret += fmt->width(fmt, &dummy_hpp, hists); 637 } 638 639 if (verbose && hists__has(hists, sym)) /* Addr + origin */ 640 ret += 3 + BITS_PER_LONG / 4; 641 642 return ret; 643 } 644 645 unsigned int hists__overhead_width(struct hists *hists) 646 { 647 struct perf_hpp_fmt *fmt; 648 int ret = 0; 649 bool first = true; 650 struct perf_hpp dummy_hpp; 651 652 hists__for_each_format(hists, fmt) { 653 if (perf_hpp__is_sort_entry(fmt) || perf_hpp__is_dynamic_entry(fmt)) 654 break; 655 656 if (first) 657 first = false; 658 else 659 ret += 2; 660 661 ret += fmt->width(fmt, &dummy_hpp, hists); 662 } 663 664 return ret; 665 } 666 667 void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists) 668 { 669 if (perf_hpp__is_sort_entry(fmt)) 670 return perf_hpp__reset_sort_width(fmt, hists); 671 672 if (perf_hpp__is_dynamic_entry(fmt)) 673 return; 674 675 BUG_ON(fmt->idx >= PERF_HPP__MAX_INDEX); 676 677 switch (fmt->idx) { 678 case PERF_HPP__OVERHEAD: 679 case PERF_HPP__OVERHEAD_SYS: 680 case PERF_HPP__OVERHEAD_US: 681 case PERF_HPP__OVERHEAD_ACC: 682 fmt->len = 8; 683 break; 684 685 case PERF_HPP__OVERHEAD_GUEST_SYS: 686 case PERF_HPP__OVERHEAD_GUEST_US: 687 fmt->len = 9; 688 break; 689 690 case PERF_HPP__SAMPLES: 691 case PERF_HPP__PERIOD: 692 fmt->len = 12; 693 break; 694 695 default: 696 break; 697 } 698 } 699 700 void perf_hpp__set_user_width(const char *width_list_str) 701 { 702 struct perf_hpp_fmt *fmt; 703 const char *ptr = width_list_str; 704 705 perf_hpp_list__for_each_format(&perf_hpp_list, fmt) { 706 char *p; 707 708 int len = strtol(ptr, &p, 10); 709 fmt->user_len = len; 710 711 if (*p == ',') 712 ptr = p + 1; 713 else 714 break; 715 } 716 } 717 718 static int add_hierarchy_fmt(struct hists *hists, struct perf_hpp_fmt *fmt) 719 { 720 struct perf_hpp_list_node *node = NULL; 721 struct perf_hpp_fmt *fmt_copy; 722 bool found = false; 723 bool skip = perf_hpp__should_skip(fmt, hists); 724 725 list_for_each_entry(node, &hists->hpp_formats, list) { 726 if (node->level == fmt->level) { 727 found = true; 728 break; 729 } 730 } 731 732 if (!found) { 733 node = malloc(sizeof(*node)); 734 if (node == NULL) 735 return -1; 736 737 node->skip = skip; 738 node->level = fmt->level; 739 perf_hpp_list__init(&node->hpp); 740 741 hists->nr_hpp_node++; 742 list_add_tail(&node->list, &hists->hpp_formats); 743 } 744 745 fmt_copy = perf_hpp_fmt__dup(fmt); 746 if (fmt_copy == NULL) 747 return -1; 748 749 if (!skip) 750 node->skip = false; 751 752 list_add_tail(&fmt_copy->list, &node->hpp.fields); 753 list_add_tail(&fmt_copy->sort_list, &node->hpp.sorts); 754 755 return 0; 756 } 757 758 int perf_hpp__setup_hists_formats(struct perf_hpp_list *list, 759 struct perf_evlist *evlist) 760 { 761 struct perf_evsel *evsel; 762 struct perf_hpp_fmt *fmt; 763 struct hists *hists; 764 int ret; 765 766 if (!symbol_conf.report_hierarchy) 767 return 0; 768 769 evlist__for_each_entry(evlist, evsel) { 770 hists = evsel__hists(evsel); 771 772 perf_hpp_list__for_each_sort_list(list, fmt) { 773 if (perf_hpp__is_dynamic_entry(fmt) && 774 !perf_hpp__defined_dynamic_entry(fmt, hists)) 775 continue; 776 777 ret = add_hierarchy_fmt(hists, fmt); 778 if (ret < 0) 779 return ret; 780 } 781 } 782 783 return 0; 784 } 785