1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * This is rewrite of original c2c tool introduced in here: 4 * http://lwn.net/Articles/588866/ 5 * 6 * The original tool was changed to fit in current perf state. 7 * 8 * Original authors: 9 * Don Zickus <dzickus@redhat.com> 10 * Dick Fowles <fowles@inreach.com> 11 * Joe Mario <jmario@redhat.com> 12 */ 13 #include <errno.h> 14 #include <inttypes.h> 15 #include <linux/compiler.h> 16 #include <linux/err.h> 17 #include <linux/kernel.h> 18 #include <linux/stringify.h> 19 #include <linux/zalloc.h> 20 #include <asm/bug.h> 21 #include <sys/param.h> 22 #include "debug.h" 23 #include "builtin.h" 24 #include <perf/cpumap.h> 25 #include <subcmd/pager.h> 26 #include <subcmd/parse-options.h> 27 #include "map_symbol.h" 28 #include "mem-events.h" 29 #include "session.h" 30 #include "hist.h" 31 #include "sort.h" 32 #include "tool.h" 33 #include "cacheline.h" 34 #include "data.h" 35 #include "event.h" 36 #include "evlist.h" 37 #include "evsel.h" 38 #include "ui/browsers/hists.h" 39 #include "thread.h" 40 #include "mem2node.h" 41 #include "symbol.h" 42 #include "ui/ui.h" 43 #include "ui/progress.h" 44 #include "../perf.h" 45 #include "pmu.h" 46 #include "pmu-hybrid.h" 47 #include "string2.h" 48 49 struct c2c_hists { 50 struct hists hists; 51 struct perf_hpp_list list; 52 struct c2c_stats stats; 53 }; 54 55 struct compute_stats { 56 struct stats lcl_hitm; 57 struct stats rmt_hitm; 58 struct stats lcl_peer; 59 struct stats rmt_peer; 60 struct stats load; 61 }; 62 63 struct c2c_hist_entry { 64 struct c2c_hists *hists; 65 struct c2c_stats stats; 66 unsigned long *cpuset; 67 unsigned long *nodeset; 68 struct c2c_stats *node_stats; 69 unsigned int cacheline_idx; 70 71 struct compute_stats cstats; 72 73 unsigned long paddr; 74 unsigned long paddr_cnt; 75 bool paddr_zero; 76 char *nodestr; 77 78 /* 79 * must be at the end, 80 * because of its callchain dynamic entry 81 */ 82 struct hist_entry he; 83 }; 84 85 static char const *coalesce_default = "iaddr"; 86 87 struct perf_c2c { 88 struct perf_tool tool; 89 struct c2c_hists hists; 90 struct mem2node mem2node; 91 92 unsigned long **nodes; 93 int nodes_cnt; 94 int cpus_cnt; 95 int *cpu2node; 96 int node_info; 97 98 bool show_src; 99 bool show_all; 100 bool use_stdio; 101 bool stats_only; 102 bool symbol_full; 103 bool stitch_lbr; 104 105 /* Shared cache line stats */ 106 struct c2c_stats shared_clines_stats; 107 int shared_clines; 108 109 int display; 110 111 const char *coalesce; 112 char *cl_sort; 113 char *cl_resort; 114 char *cl_output; 115 }; 116 117 enum { 118 DISPLAY_LCL_HITM, 119 DISPLAY_RMT_HITM, 120 DISPLAY_TOT_HITM, 121 DISPLAY_SNP_PEER, 122 DISPLAY_MAX, 123 }; 124 125 static const char *display_str[DISPLAY_MAX] = { 126 [DISPLAY_LCL_HITM] = "Local HITMs", 127 [DISPLAY_RMT_HITM] = "Remote HITMs", 128 [DISPLAY_TOT_HITM] = "Total HITMs", 129 [DISPLAY_SNP_PEER] = "Peer Snoop", 130 }; 131 132 static const struct option c2c_options[] = { 133 OPT_INCR('v', "verbose", &verbose, "be more verbose (show counter open errors, etc)"), 134 OPT_END() 135 }; 136 137 static struct perf_c2c c2c; 138 139 static void *c2c_he_zalloc(size_t size) 140 { 141 struct c2c_hist_entry *c2c_he; 142 143 c2c_he = zalloc(size + sizeof(*c2c_he)); 144 if (!c2c_he) 145 return NULL; 146 147 c2c_he->cpuset = bitmap_zalloc(c2c.cpus_cnt); 148 if (!c2c_he->cpuset) 149 return NULL; 150 151 c2c_he->nodeset = bitmap_zalloc(c2c.nodes_cnt); 152 if (!c2c_he->nodeset) 153 return NULL; 154 155 c2c_he->node_stats = zalloc(c2c.nodes_cnt * sizeof(*c2c_he->node_stats)); 156 if (!c2c_he->node_stats) 157 return NULL; 158 159 init_stats(&c2c_he->cstats.lcl_hitm); 160 init_stats(&c2c_he->cstats.rmt_hitm); 161 init_stats(&c2c_he->cstats.lcl_peer); 162 init_stats(&c2c_he->cstats.rmt_peer); 163 init_stats(&c2c_he->cstats.load); 164 165 return &c2c_he->he; 166 } 167 168 static void c2c_he_free(void *he) 169 { 170 struct c2c_hist_entry *c2c_he; 171 172 c2c_he = container_of(he, struct c2c_hist_entry, he); 173 if (c2c_he->hists) { 174 hists__delete_entries(&c2c_he->hists->hists); 175 free(c2c_he->hists); 176 } 177 178 free(c2c_he->cpuset); 179 free(c2c_he->nodeset); 180 free(c2c_he->nodestr); 181 free(c2c_he->node_stats); 182 free(c2c_he); 183 } 184 185 static struct hist_entry_ops c2c_entry_ops = { 186 .new = c2c_he_zalloc, 187 .free = c2c_he_free, 188 }; 189 190 static int c2c_hists__init(struct c2c_hists *hists, 191 const char *sort, 192 int nr_header_lines); 193 194 static struct c2c_hists* 195 he__get_c2c_hists(struct hist_entry *he, 196 const char *sort, 197 int nr_header_lines) 198 { 199 struct c2c_hist_entry *c2c_he; 200 struct c2c_hists *hists; 201 int ret; 202 203 c2c_he = container_of(he, struct c2c_hist_entry, he); 204 if (c2c_he->hists) 205 return c2c_he->hists; 206 207 hists = c2c_he->hists = zalloc(sizeof(*hists)); 208 if (!hists) 209 return NULL; 210 211 ret = c2c_hists__init(hists, sort, nr_header_lines); 212 if (ret) { 213 free(hists); 214 return NULL; 215 } 216 217 return hists; 218 } 219 220 static void c2c_he__set_cpu(struct c2c_hist_entry *c2c_he, 221 struct perf_sample *sample) 222 { 223 if (WARN_ONCE(sample->cpu == (unsigned int) -1, 224 "WARNING: no sample cpu value")) 225 return; 226 227 set_bit(sample->cpu, c2c_he->cpuset); 228 } 229 230 static void c2c_he__set_node(struct c2c_hist_entry *c2c_he, 231 struct perf_sample *sample) 232 { 233 int node; 234 235 if (!sample->phys_addr) { 236 c2c_he->paddr_zero = true; 237 return; 238 } 239 240 node = mem2node__node(&c2c.mem2node, sample->phys_addr); 241 if (WARN_ONCE(node < 0, "WARNING: failed to find node\n")) 242 return; 243 244 set_bit(node, c2c_he->nodeset); 245 246 if (c2c_he->paddr != sample->phys_addr) { 247 c2c_he->paddr_cnt++; 248 c2c_he->paddr = sample->phys_addr; 249 } 250 } 251 252 static void compute_stats(struct c2c_hist_entry *c2c_he, 253 struct c2c_stats *stats, 254 u64 weight) 255 { 256 struct compute_stats *cstats = &c2c_he->cstats; 257 258 if (stats->rmt_hitm) 259 update_stats(&cstats->rmt_hitm, weight); 260 else if (stats->lcl_hitm) 261 update_stats(&cstats->lcl_hitm, weight); 262 else if (stats->rmt_peer) 263 update_stats(&cstats->rmt_peer, weight); 264 else if (stats->lcl_peer) 265 update_stats(&cstats->lcl_peer, weight); 266 else if (stats->load) 267 update_stats(&cstats->load, weight); 268 } 269 270 static int process_sample_event(struct perf_tool *tool __maybe_unused, 271 union perf_event *event, 272 struct perf_sample *sample, 273 struct evsel *evsel, 274 struct machine *machine) 275 { 276 struct c2c_hists *c2c_hists = &c2c.hists; 277 struct c2c_hist_entry *c2c_he; 278 struct c2c_stats stats = { .nr_entries = 0, }; 279 struct hist_entry *he; 280 struct addr_location al; 281 struct mem_info *mi, *mi_dup; 282 int ret; 283 284 if (machine__resolve(machine, &al, sample) < 0) { 285 pr_debug("problem processing %d event, skipping it.\n", 286 event->header.type); 287 return -1; 288 } 289 290 if (c2c.stitch_lbr) 291 al.thread->lbr_stitch_enable = true; 292 293 ret = sample__resolve_callchain(sample, &callchain_cursor, NULL, 294 evsel, &al, sysctl_perf_event_max_stack); 295 if (ret) 296 goto out; 297 298 mi = sample__resolve_mem(sample, &al); 299 if (mi == NULL) 300 return -ENOMEM; 301 302 /* 303 * The mi object is released in hists__add_entry_ops, 304 * if it gets sorted out into existing data, so we need 305 * to take the copy now. 306 */ 307 mi_dup = mem_info__get(mi); 308 309 c2c_decode_stats(&stats, mi); 310 311 he = hists__add_entry_ops(&c2c_hists->hists, &c2c_entry_ops, 312 &al, NULL, NULL, mi, 313 sample, true); 314 if (he == NULL) 315 goto free_mi; 316 317 c2c_he = container_of(he, struct c2c_hist_entry, he); 318 c2c_add_stats(&c2c_he->stats, &stats); 319 c2c_add_stats(&c2c_hists->stats, &stats); 320 321 c2c_he__set_cpu(c2c_he, sample); 322 c2c_he__set_node(c2c_he, sample); 323 324 hists__inc_nr_samples(&c2c_hists->hists, he->filtered); 325 ret = hist_entry__append_callchain(he, sample); 326 327 if (!ret) { 328 /* 329 * There's already been warning about missing 330 * sample's cpu value. Let's account all to 331 * node 0 in this case, without any further 332 * warning. 333 * 334 * Doing node stats only for single callchain data. 335 */ 336 int cpu = sample->cpu == (unsigned int) -1 ? 0 : sample->cpu; 337 int node = c2c.cpu2node[cpu]; 338 339 mi = mi_dup; 340 341 c2c_hists = he__get_c2c_hists(he, c2c.cl_sort, 2); 342 if (!c2c_hists) 343 goto free_mi; 344 345 he = hists__add_entry_ops(&c2c_hists->hists, &c2c_entry_ops, 346 &al, NULL, NULL, mi, 347 sample, true); 348 if (he == NULL) 349 goto free_mi; 350 351 c2c_he = container_of(he, struct c2c_hist_entry, he); 352 c2c_add_stats(&c2c_he->stats, &stats); 353 c2c_add_stats(&c2c_hists->stats, &stats); 354 c2c_add_stats(&c2c_he->node_stats[node], &stats); 355 356 compute_stats(c2c_he, &stats, sample->weight); 357 358 c2c_he__set_cpu(c2c_he, sample); 359 c2c_he__set_node(c2c_he, sample); 360 361 hists__inc_nr_samples(&c2c_hists->hists, he->filtered); 362 ret = hist_entry__append_callchain(he, sample); 363 } 364 365 out: 366 addr_location__put(&al); 367 return ret; 368 369 free_mi: 370 mem_info__put(mi_dup); 371 mem_info__put(mi); 372 ret = -ENOMEM; 373 goto out; 374 } 375 376 static struct perf_c2c c2c = { 377 .tool = { 378 .sample = process_sample_event, 379 .mmap = perf_event__process_mmap, 380 .mmap2 = perf_event__process_mmap2, 381 .comm = perf_event__process_comm, 382 .exit = perf_event__process_exit, 383 .fork = perf_event__process_fork, 384 .lost = perf_event__process_lost, 385 .attr = perf_event__process_attr, 386 .auxtrace_info = perf_event__process_auxtrace_info, 387 .auxtrace = perf_event__process_auxtrace, 388 .auxtrace_error = perf_event__process_auxtrace_error, 389 .ordered_events = true, 390 .ordering_requires_timestamps = true, 391 }, 392 }; 393 394 static const char * const c2c_usage[] = { 395 "perf c2c {record|report}", 396 NULL 397 }; 398 399 static const char * const __usage_report[] = { 400 "perf c2c report", 401 NULL 402 }; 403 404 static const char * const *report_c2c_usage = __usage_report; 405 406 #define C2C_HEADER_MAX 2 407 408 struct c2c_header { 409 struct { 410 const char *text; 411 int span; 412 } line[C2C_HEADER_MAX]; 413 }; 414 415 struct c2c_dimension { 416 struct c2c_header header; 417 const char *name; 418 int width; 419 struct sort_entry *se; 420 421 int64_t (*cmp)(struct perf_hpp_fmt *fmt, 422 struct hist_entry *, struct hist_entry *); 423 int (*entry)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 424 struct hist_entry *he); 425 int (*color)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 426 struct hist_entry *he); 427 }; 428 429 struct c2c_fmt { 430 struct perf_hpp_fmt fmt; 431 struct c2c_dimension *dim; 432 }; 433 434 #define SYMBOL_WIDTH 30 435 436 static struct c2c_dimension dim_symbol; 437 static struct c2c_dimension dim_srcline; 438 439 static int symbol_width(struct hists *hists, struct sort_entry *se) 440 { 441 int width = hists__col_len(hists, se->se_width_idx); 442 443 if (!c2c.symbol_full) 444 width = MIN(width, SYMBOL_WIDTH); 445 446 return width; 447 } 448 449 static int c2c_width(struct perf_hpp_fmt *fmt, 450 struct perf_hpp *hpp __maybe_unused, 451 struct hists *hists) 452 { 453 struct c2c_fmt *c2c_fmt; 454 struct c2c_dimension *dim; 455 456 c2c_fmt = container_of(fmt, struct c2c_fmt, fmt); 457 dim = c2c_fmt->dim; 458 459 if (dim == &dim_symbol || dim == &dim_srcline) 460 return symbol_width(hists, dim->se); 461 462 return dim->se ? hists__col_len(hists, dim->se->se_width_idx) : 463 c2c_fmt->dim->width; 464 } 465 466 static int c2c_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 467 struct hists *hists, int line, int *span) 468 { 469 struct perf_hpp_list *hpp_list = hists->hpp_list; 470 struct c2c_fmt *c2c_fmt; 471 struct c2c_dimension *dim; 472 const char *text = NULL; 473 int width = c2c_width(fmt, hpp, hists); 474 475 c2c_fmt = container_of(fmt, struct c2c_fmt, fmt); 476 dim = c2c_fmt->dim; 477 478 if (dim->se) { 479 text = dim->header.line[line].text; 480 /* Use the last line from sort_entry if not defined. */ 481 if (!text && (line == hpp_list->nr_header_lines - 1)) 482 text = dim->se->se_header; 483 } else { 484 text = dim->header.line[line].text; 485 486 if (*span) { 487 (*span)--; 488 return 0; 489 } else { 490 *span = dim->header.line[line].span; 491 } 492 } 493 494 if (text == NULL) 495 text = ""; 496 497 return scnprintf(hpp->buf, hpp->size, "%*s", width, text); 498 } 499 500 #define HEX_STR(__s, __v) \ 501 ({ \ 502 scnprintf(__s, sizeof(__s), "0x%" PRIx64, __v); \ 503 __s; \ 504 }) 505 506 static int64_t 507 dcacheline_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 508 struct hist_entry *left, struct hist_entry *right) 509 { 510 return sort__dcacheline_cmp(left, right); 511 } 512 513 static int dcacheline_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 514 struct hist_entry *he) 515 { 516 uint64_t addr = 0; 517 int width = c2c_width(fmt, hpp, he->hists); 518 char buf[20]; 519 520 if (he->mem_info) 521 addr = cl_address(he->mem_info->daddr.addr); 522 523 return scnprintf(hpp->buf, hpp->size, "%*s", width, HEX_STR(buf, addr)); 524 } 525 526 static int 527 dcacheline_node_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 528 struct hist_entry *he) 529 { 530 struct c2c_hist_entry *c2c_he; 531 int width = c2c_width(fmt, hpp, he->hists); 532 533 c2c_he = container_of(he, struct c2c_hist_entry, he); 534 if (WARN_ON_ONCE(!c2c_he->nodestr)) 535 return 0; 536 537 return scnprintf(hpp->buf, hpp->size, "%*s", width, c2c_he->nodestr); 538 } 539 540 static int 541 dcacheline_node_count(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 542 struct hist_entry *he) 543 { 544 struct c2c_hist_entry *c2c_he; 545 int width = c2c_width(fmt, hpp, he->hists); 546 547 c2c_he = container_of(he, struct c2c_hist_entry, he); 548 return scnprintf(hpp->buf, hpp->size, "%*lu", width, c2c_he->paddr_cnt); 549 } 550 551 static int offset_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 552 struct hist_entry *he) 553 { 554 uint64_t addr = 0; 555 int width = c2c_width(fmt, hpp, he->hists); 556 char buf[20]; 557 558 if (he->mem_info) 559 addr = cl_offset(he->mem_info->daddr.al_addr); 560 561 return scnprintf(hpp->buf, hpp->size, "%*s", width, HEX_STR(buf, addr)); 562 } 563 564 static int64_t 565 offset_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 566 struct hist_entry *left, struct hist_entry *right) 567 { 568 uint64_t l = 0, r = 0; 569 570 if (left->mem_info) 571 l = cl_offset(left->mem_info->daddr.addr); 572 if (right->mem_info) 573 r = cl_offset(right->mem_info->daddr.addr); 574 575 return (int64_t)(r - l); 576 } 577 578 static int 579 iaddr_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 580 struct hist_entry *he) 581 { 582 uint64_t addr = 0; 583 int width = c2c_width(fmt, hpp, he->hists); 584 char buf[20]; 585 586 if (he->mem_info) 587 addr = he->mem_info->iaddr.addr; 588 589 return scnprintf(hpp->buf, hpp->size, "%*s", width, HEX_STR(buf, addr)); 590 } 591 592 static int64_t 593 iaddr_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 594 struct hist_entry *left, struct hist_entry *right) 595 { 596 return sort__iaddr_cmp(left, right); 597 } 598 599 static int 600 tot_hitm_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 601 struct hist_entry *he) 602 { 603 struct c2c_hist_entry *c2c_he; 604 int width = c2c_width(fmt, hpp, he->hists); 605 unsigned int tot_hitm; 606 607 c2c_he = container_of(he, struct c2c_hist_entry, he); 608 tot_hitm = c2c_he->stats.lcl_hitm + c2c_he->stats.rmt_hitm; 609 610 return scnprintf(hpp->buf, hpp->size, "%*u", width, tot_hitm); 611 } 612 613 static int64_t 614 tot_hitm_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 615 struct hist_entry *left, struct hist_entry *right) 616 { 617 struct c2c_hist_entry *c2c_left; 618 struct c2c_hist_entry *c2c_right; 619 uint64_t tot_hitm_left; 620 uint64_t tot_hitm_right; 621 622 c2c_left = container_of(left, struct c2c_hist_entry, he); 623 c2c_right = container_of(right, struct c2c_hist_entry, he); 624 625 tot_hitm_left = c2c_left->stats.lcl_hitm + c2c_left->stats.rmt_hitm; 626 tot_hitm_right = c2c_right->stats.lcl_hitm + c2c_right->stats.rmt_hitm; 627 628 return tot_hitm_left - tot_hitm_right; 629 } 630 631 #define STAT_FN_ENTRY(__f) \ 632 static int \ 633 __f ## _entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, \ 634 struct hist_entry *he) \ 635 { \ 636 struct c2c_hist_entry *c2c_he; \ 637 int width = c2c_width(fmt, hpp, he->hists); \ 638 \ 639 c2c_he = container_of(he, struct c2c_hist_entry, he); \ 640 return scnprintf(hpp->buf, hpp->size, "%*u", width, \ 641 c2c_he->stats.__f); \ 642 } 643 644 #define STAT_FN_CMP(__f) \ 645 static int64_t \ 646 __f ## _cmp(struct perf_hpp_fmt *fmt __maybe_unused, \ 647 struct hist_entry *left, struct hist_entry *right) \ 648 { \ 649 struct c2c_hist_entry *c2c_left, *c2c_right; \ 650 \ 651 c2c_left = container_of(left, struct c2c_hist_entry, he); \ 652 c2c_right = container_of(right, struct c2c_hist_entry, he); \ 653 return (uint64_t) c2c_left->stats.__f - \ 654 (uint64_t) c2c_right->stats.__f; \ 655 } 656 657 #define STAT_FN(__f) \ 658 STAT_FN_ENTRY(__f) \ 659 STAT_FN_CMP(__f) 660 661 STAT_FN(rmt_hitm) 662 STAT_FN(lcl_hitm) 663 STAT_FN(rmt_peer) 664 STAT_FN(lcl_peer) 665 STAT_FN(tot_peer) 666 STAT_FN(store) 667 STAT_FN(st_l1hit) 668 STAT_FN(st_l1miss) 669 STAT_FN(st_na) 670 STAT_FN(ld_fbhit) 671 STAT_FN(ld_l1hit) 672 STAT_FN(ld_l2hit) 673 STAT_FN(ld_llchit) 674 STAT_FN(rmt_hit) 675 676 static uint64_t total_records(struct c2c_stats *stats) 677 { 678 uint64_t lclmiss, ldcnt, total; 679 680 lclmiss = stats->lcl_dram + 681 stats->rmt_dram + 682 stats->rmt_hitm + 683 stats->rmt_hit; 684 685 ldcnt = lclmiss + 686 stats->ld_fbhit + 687 stats->ld_l1hit + 688 stats->ld_l2hit + 689 stats->ld_llchit + 690 stats->lcl_hitm; 691 692 total = ldcnt + 693 stats->st_l1hit + 694 stats->st_l1miss + 695 stats->st_na; 696 697 return total; 698 } 699 700 static int 701 tot_recs_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 702 struct hist_entry *he) 703 { 704 struct c2c_hist_entry *c2c_he; 705 int width = c2c_width(fmt, hpp, he->hists); 706 uint64_t tot_recs; 707 708 c2c_he = container_of(he, struct c2c_hist_entry, he); 709 tot_recs = total_records(&c2c_he->stats); 710 711 return scnprintf(hpp->buf, hpp->size, "%*" PRIu64, width, tot_recs); 712 } 713 714 static int64_t 715 tot_recs_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 716 struct hist_entry *left, struct hist_entry *right) 717 { 718 struct c2c_hist_entry *c2c_left; 719 struct c2c_hist_entry *c2c_right; 720 uint64_t tot_recs_left; 721 uint64_t tot_recs_right; 722 723 c2c_left = container_of(left, struct c2c_hist_entry, he); 724 c2c_right = container_of(right, struct c2c_hist_entry, he); 725 726 tot_recs_left = total_records(&c2c_left->stats); 727 tot_recs_right = total_records(&c2c_right->stats); 728 729 return tot_recs_left - tot_recs_right; 730 } 731 732 static uint64_t total_loads(struct c2c_stats *stats) 733 { 734 uint64_t lclmiss, ldcnt; 735 736 lclmiss = stats->lcl_dram + 737 stats->rmt_dram + 738 stats->rmt_hitm + 739 stats->rmt_hit; 740 741 ldcnt = lclmiss + 742 stats->ld_fbhit + 743 stats->ld_l1hit + 744 stats->ld_l2hit + 745 stats->ld_llchit + 746 stats->lcl_hitm; 747 748 return ldcnt; 749 } 750 751 static int 752 tot_loads_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 753 struct hist_entry *he) 754 { 755 struct c2c_hist_entry *c2c_he; 756 int width = c2c_width(fmt, hpp, he->hists); 757 uint64_t tot_recs; 758 759 c2c_he = container_of(he, struct c2c_hist_entry, he); 760 tot_recs = total_loads(&c2c_he->stats); 761 762 return scnprintf(hpp->buf, hpp->size, "%*" PRIu64, width, tot_recs); 763 } 764 765 static int64_t 766 tot_loads_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 767 struct hist_entry *left, struct hist_entry *right) 768 { 769 struct c2c_hist_entry *c2c_left; 770 struct c2c_hist_entry *c2c_right; 771 uint64_t tot_recs_left; 772 uint64_t tot_recs_right; 773 774 c2c_left = container_of(left, struct c2c_hist_entry, he); 775 c2c_right = container_of(right, struct c2c_hist_entry, he); 776 777 tot_recs_left = total_loads(&c2c_left->stats); 778 tot_recs_right = total_loads(&c2c_right->stats); 779 780 return tot_recs_left - tot_recs_right; 781 } 782 783 typedef double (get_percent_cb)(struct c2c_hist_entry *); 784 785 static int 786 percent_color(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 787 struct hist_entry *he, get_percent_cb get_percent) 788 { 789 struct c2c_hist_entry *c2c_he; 790 int width = c2c_width(fmt, hpp, he->hists); 791 double per; 792 793 c2c_he = container_of(he, struct c2c_hist_entry, he); 794 per = get_percent(c2c_he); 795 796 #ifdef HAVE_SLANG_SUPPORT 797 if (use_browser) 798 return __hpp__slsmg_color_printf(hpp, "%*.2f%%", width - 1, per); 799 #endif 800 return hpp_color_scnprintf(hpp, "%*.2f%%", width - 1, per); 801 } 802 803 static double percent_costly_snoop(struct c2c_hist_entry *c2c_he) 804 { 805 struct c2c_hists *hists; 806 struct c2c_stats *stats; 807 struct c2c_stats *total; 808 int tot = 0, st = 0; 809 double p; 810 811 hists = container_of(c2c_he->he.hists, struct c2c_hists, hists); 812 stats = &c2c_he->stats; 813 total = &hists->stats; 814 815 switch (c2c.display) { 816 case DISPLAY_RMT_HITM: 817 st = stats->rmt_hitm; 818 tot = total->rmt_hitm; 819 break; 820 case DISPLAY_LCL_HITM: 821 st = stats->lcl_hitm; 822 tot = total->lcl_hitm; 823 break; 824 case DISPLAY_TOT_HITM: 825 st = stats->tot_hitm; 826 tot = total->tot_hitm; 827 break; 828 case DISPLAY_SNP_PEER: 829 st = stats->tot_peer; 830 tot = total->tot_peer; 831 break; 832 default: 833 break; 834 } 835 836 p = tot ? (double) st / tot : 0; 837 838 return 100 * p; 839 } 840 841 #define PERC_STR(__s, __v) \ 842 ({ \ 843 scnprintf(__s, sizeof(__s), "%.2F%%", __v); \ 844 __s; \ 845 }) 846 847 static int 848 percent_costly_snoop_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 849 struct hist_entry *he) 850 { 851 struct c2c_hist_entry *c2c_he; 852 int width = c2c_width(fmt, hpp, he->hists); 853 char buf[10]; 854 double per; 855 856 c2c_he = container_of(he, struct c2c_hist_entry, he); 857 per = percent_costly_snoop(c2c_he); 858 return scnprintf(hpp->buf, hpp->size, "%*s", width, PERC_STR(buf, per)); 859 } 860 861 static int 862 percent_costly_snoop_color(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 863 struct hist_entry *he) 864 { 865 return percent_color(fmt, hpp, he, percent_costly_snoop); 866 } 867 868 static int64_t 869 percent_costly_snoop_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 870 struct hist_entry *left, struct hist_entry *right) 871 { 872 struct c2c_hist_entry *c2c_left; 873 struct c2c_hist_entry *c2c_right; 874 double per_left; 875 double per_right; 876 877 c2c_left = container_of(left, struct c2c_hist_entry, he); 878 c2c_right = container_of(right, struct c2c_hist_entry, he); 879 880 per_left = percent_costly_snoop(c2c_left); 881 per_right = percent_costly_snoop(c2c_right); 882 883 return per_left - per_right; 884 } 885 886 static struct c2c_stats *he_stats(struct hist_entry *he) 887 { 888 struct c2c_hist_entry *c2c_he; 889 890 c2c_he = container_of(he, struct c2c_hist_entry, he); 891 return &c2c_he->stats; 892 } 893 894 static struct c2c_stats *total_stats(struct hist_entry *he) 895 { 896 struct c2c_hists *hists; 897 898 hists = container_of(he->hists, struct c2c_hists, hists); 899 return &hists->stats; 900 } 901 902 static double percent(u32 st, u32 tot) 903 { 904 return tot ? 100. * (double) st / (double) tot : 0; 905 } 906 907 #define PERCENT(__h, __f) percent(he_stats(__h)->__f, total_stats(__h)->__f) 908 909 #define PERCENT_FN(__f) \ 910 static double percent_ ## __f(struct c2c_hist_entry *c2c_he) \ 911 { \ 912 struct c2c_hists *hists; \ 913 \ 914 hists = container_of(c2c_he->he.hists, struct c2c_hists, hists); \ 915 return percent(c2c_he->stats.__f, hists->stats.__f); \ 916 } 917 918 PERCENT_FN(rmt_hitm) 919 PERCENT_FN(lcl_hitm) 920 PERCENT_FN(rmt_peer) 921 PERCENT_FN(lcl_peer) 922 PERCENT_FN(st_l1hit) 923 PERCENT_FN(st_l1miss) 924 PERCENT_FN(st_na) 925 926 static int 927 percent_rmt_hitm_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 928 struct hist_entry *he) 929 { 930 int width = c2c_width(fmt, hpp, he->hists); 931 double per = PERCENT(he, rmt_hitm); 932 char buf[10]; 933 934 return scnprintf(hpp->buf, hpp->size, "%*s", width, PERC_STR(buf, per)); 935 } 936 937 static int 938 percent_rmt_hitm_color(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 939 struct hist_entry *he) 940 { 941 return percent_color(fmt, hpp, he, percent_rmt_hitm); 942 } 943 944 static int64_t 945 percent_rmt_hitm_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 946 struct hist_entry *left, struct hist_entry *right) 947 { 948 double per_left; 949 double per_right; 950 951 per_left = PERCENT(left, rmt_hitm); 952 per_right = PERCENT(right, rmt_hitm); 953 954 return per_left - per_right; 955 } 956 957 static int 958 percent_lcl_hitm_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 959 struct hist_entry *he) 960 { 961 int width = c2c_width(fmt, hpp, he->hists); 962 double per = PERCENT(he, lcl_hitm); 963 char buf[10]; 964 965 return scnprintf(hpp->buf, hpp->size, "%*s", width, PERC_STR(buf, per)); 966 } 967 968 static int 969 percent_lcl_hitm_color(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 970 struct hist_entry *he) 971 { 972 return percent_color(fmt, hpp, he, percent_lcl_hitm); 973 } 974 975 static int64_t 976 percent_lcl_hitm_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 977 struct hist_entry *left, struct hist_entry *right) 978 { 979 double per_left; 980 double per_right; 981 982 per_left = PERCENT(left, lcl_hitm); 983 per_right = PERCENT(right, lcl_hitm); 984 985 return per_left - per_right; 986 } 987 988 static int 989 percent_lcl_peer_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 990 struct hist_entry *he) 991 { 992 int width = c2c_width(fmt, hpp, he->hists); 993 double per = PERCENT(he, lcl_peer); 994 char buf[10]; 995 996 return scnprintf(hpp->buf, hpp->size, "%*s", width, PERC_STR(buf, per)); 997 } 998 999 static int 1000 percent_lcl_peer_color(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1001 struct hist_entry *he) 1002 { 1003 return percent_color(fmt, hpp, he, percent_lcl_peer); 1004 } 1005 1006 static int64_t 1007 percent_lcl_peer_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 1008 struct hist_entry *left, struct hist_entry *right) 1009 { 1010 double per_left; 1011 double per_right; 1012 1013 per_left = PERCENT(left, lcl_peer); 1014 per_right = PERCENT(right, lcl_peer); 1015 1016 return per_left - per_right; 1017 } 1018 1019 static int 1020 percent_rmt_peer_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1021 struct hist_entry *he) 1022 { 1023 int width = c2c_width(fmt, hpp, he->hists); 1024 double per = PERCENT(he, rmt_peer); 1025 char buf[10]; 1026 1027 return scnprintf(hpp->buf, hpp->size, "%*s", width, PERC_STR(buf, per)); 1028 } 1029 1030 static int 1031 percent_rmt_peer_color(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1032 struct hist_entry *he) 1033 { 1034 return percent_color(fmt, hpp, he, percent_rmt_peer); 1035 } 1036 1037 static int64_t 1038 percent_rmt_peer_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 1039 struct hist_entry *left, struct hist_entry *right) 1040 { 1041 double per_left; 1042 double per_right; 1043 1044 per_left = PERCENT(left, rmt_peer); 1045 per_right = PERCENT(right, rmt_peer); 1046 1047 return per_left - per_right; 1048 } 1049 1050 static int 1051 percent_stores_l1hit_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1052 struct hist_entry *he) 1053 { 1054 int width = c2c_width(fmt, hpp, he->hists); 1055 double per = PERCENT(he, st_l1hit); 1056 char buf[10]; 1057 1058 return scnprintf(hpp->buf, hpp->size, "%*s", width, PERC_STR(buf, per)); 1059 } 1060 1061 static int 1062 percent_stores_l1hit_color(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1063 struct hist_entry *he) 1064 { 1065 return percent_color(fmt, hpp, he, percent_st_l1hit); 1066 } 1067 1068 static int64_t 1069 percent_stores_l1hit_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 1070 struct hist_entry *left, struct hist_entry *right) 1071 { 1072 double per_left; 1073 double per_right; 1074 1075 per_left = PERCENT(left, st_l1hit); 1076 per_right = PERCENT(right, st_l1hit); 1077 1078 return per_left - per_right; 1079 } 1080 1081 static int 1082 percent_stores_l1miss_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1083 struct hist_entry *he) 1084 { 1085 int width = c2c_width(fmt, hpp, he->hists); 1086 double per = PERCENT(he, st_l1miss); 1087 char buf[10]; 1088 1089 return scnprintf(hpp->buf, hpp->size, "%*s", width, PERC_STR(buf, per)); 1090 } 1091 1092 static int 1093 percent_stores_l1miss_color(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1094 struct hist_entry *he) 1095 { 1096 return percent_color(fmt, hpp, he, percent_st_l1miss); 1097 } 1098 1099 static int64_t 1100 percent_stores_l1miss_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 1101 struct hist_entry *left, struct hist_entry *right) 1102 { 1103 double per_left; 1104 double per_right; 1105 1106 per_left = PERCENT(left, st_l1miss); 1107 per_right = PERCENT(right, st_l1miss); 1108 1109 return per_left - per_right; 1110 } 1111 1112 static int 1113 percent_stores_na_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1114 struct hist_entry *he) 1115 { 1116 int width = c2c_width(fmt, hpp, he->hists); 1117 double per = PERCENT(he, st_na); 1118 char buf[10]; 1119 1120 return scnprintf(hpp->buf, hpp->size, "%*s", width, PERC_STR(buf, per)); 1121 } 1122 1123 static int 1124 percent_stores_na_color(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1125 struct hist_entry *he) 1126 { 1127 return percent_color(fmt, hpp, he, percent_st_na); 1128 } 1129 1130 static int64_t 1131 percent_stores_na_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 1132 struct hist_entry *left, struct hist_entry *right) 1133 { 1134 double per_left; 1135 double per_right; 1136 1137 per_left = PERCENT(left, st_na); 1138 per_right = PERCENT(right, st_na); 1139 1140 return per_left - per_right; 1141 } 1142 1143 STAT_FN(lcl_dram) 1144 STAT_FN(rmt_dram) 1145 1146 static int 1147 pid_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1148 struct hist_entry *he) 1149 { 1150 int width = c2c_width(fmt, hpp, he->hists); 1151 1152 return scnprintf(hpp->buf, hpp->size, "%*d", width, he->thread->pid_); 1153 } 1154 1155 static int64_t 1156 pid_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 1157 struct hist_entry *left, struct hist_entry *right) 1158 { 1159 return left->thread->pid_ - right->thread->pid_; 1160 } 1161 1162 static int64_t 1163 empty_cmp(struct perf_hpp_fmt *fmt __maybe_unused, 1164 struct hist_entry *left __maybe_unused, 1165 struct hist_entry *right __maybe_unused) 1166 { 1167 return 0; 1168 } 1169 1170 static int display_metrics(struct perf_hpp *hpp, u32 val, u32 sum) 1171 { 1172 int ret; 1173 1174 if (sum != 0) 1175 ret = scnprintf(hpp->buf, hpp->size, "%5.1f%% ", 1176 percent(val, sum)); 1177 else 1178 ret = scnprintf(hpp->buf, hpp->size, "%6s ", "n/a"); 1179 1180 return ret; 1181 } 1182 1183 static int 1184 node_entry(struct perf_hpp_fmt *fmt __maybe_unused, struct perf_hpp *hpp, 1185 struct hist_entry *he) 1186 { 1187 struct c2c_hist_entry *c2c_he; 1188 bool first = true; 1189 int node; 1190 int ret = 0; 1191 1192 c2c_he = container_of(he, struct c2c_hist_entry, he); 1193 1194 for (node = 0; node < c2c.nodes_cnt; node++) { 1195 DECLARE_BITMAP(set, c2c.cpus_cnt); 1196 1197 bitmap_zero(set, c2c.cpus_cnt); 1198 bitmap_and(set, c2c_he->cpuset, c2c.nodes[node], c2c.cpus_cnt); 1199 1200 if (bitmap_empty(set, c2c.cpus_cnt)) { 1201 if (c2c.node_info == 1) { 1202 ret = scnprintf(hpp->buf, hpp->size, "%21s", " "); 1203 advance_hpp(hpp, ret); 1204 } 1205 continue; 1206 } 1207 1208 if (!first) { 1209 ret = scnprintf(hpp->buf, hpp->size, " "); 1210 advance_hpp(hpp, ret); 1211 } 1212 1213 switch (c2c.node_info) { 1214 case 0: 1215 ret = scnprintf(hpp->buf, hpp->size, "%2d", node); 1216 advance_hpp(hpp, ret); 1217 break; 1218 case 1: 1219 { 1220 int num = bitmap_weight(set, c2c.cpus_cnt); 1221 struct c2c_stats *stats = &c2c_he->node_stats[node]; 1222 1223 ret = scnprintf(hpp->buf, hpp->size, "%2d{%2d ", node, num); 1224 advance_hpp(hpp, ret); 1225 1226 switch (c2c.display) { 1227 case DISPLAY_RMT_HITM: 1228 ret = display_metrics(hpp, stats->rmt_hitm, 1229 c2c_he->stats.rmt_hitm); 1230 break; 1231 case DISPLAY_LCL_HITM: 1232 ret = display_metrics(hpp, stats->lcl_hitm, 1233 c2c_he->stats.lcl_hitm); 1234 break; 1235 case DISPLAY_TOT_HITM: 1236 ret = display_metrics(hpp, stats->tot_hitm, 1237 c2c_he->stats.tot_hitm); 1238 break; 1239 case DISPLAY_SNP_PEER: 1240 ret = display_metrics(hpp, stats->tot_peer, 1241 c2c_he->stats.tot_peer); 1242 break; 1243 default: 1244 break; 1245 } 1246 1247 advance_hpp(hpp, ret); 1248 1249 if (c2c_he->stats.store > 0) { 1250 ret = scnprintf(hpp->buf, hpp->size, "%5.1f%%}", 1251 percent(stats->store, c2c_he->stats.store)); 1252 } else { 1253 ret = scnprintf(hpp->buf, hpp->size, "%6s}", "n/a"); 1254 } 1255 1256 advance_hpp(hpp, ret); 1257 break; 1258 } 1259 case 2: 1260 ret = scnprintf(hpp->buf, hpp->size, "%2d{", node); 1261 advance_hpp(hpp, ret); 1262 1263 ret = bitmap_scnprintf(set, c2c.cpus_cnt, hpp->buf, hpp->size); 1264 advance_hpp(hpp, ret); 1265 1266 ret = scnprintf(hpp->buf, hpp->size, "}"); 1267 advance_hpp(hpp, ret); 1268 break; 1269 default: 1270 break; 1271 } 1272 1273 first = false; 1274 } 1275 1276 return 0; 1277 } 1278 1279 static int 1280 mean_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1281 struct hist_entry *he, double mean) 1282 { 1283 int width = c2c_width(fmt, hpp, he->hists); 1284 char buf[10]; 1285 1286 scnprintf(buf, 10, "%6.0f", mean); 1287 return scnprintf(hpp->buf, hpp->size, "%*s", width, buf); 1288 } 1289 1290 #define MEAN_ENTRY(__func, __val) \ 1291 static int \ 1292 __func(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, struct hist_entry *he) \ 1293 { \ 1294 struct c2c_hist_entry *c2c_he; \ 1295 c2c_he = container_of(he, struct c2c_hist_entry, he); \ 1296 return mean_entry(fmt, hpp, he, avg_stats(&c2c_he->cstats.__val)); \ 1297 } 1298 1299 MEAN_ENTRY(mean_rmt_entry, rmt_hitm); 1300 MEAN_ENTRY(mean_lcl_entry, lcl_hitm); 1301 MEAN_ENTRY(mean_load_entry, load); 1302 MEAN_ENTRY(mean_rmt_peer_entry, rmt_peer); 1303 MEAN_ENTRY(mean_lcl_peer_entry, lcl_peer); 1304 1305 static int 1306 cpucnt_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1307 struct hist_entry *he) 1308 { 1309 struct c2c_hist_entry *c2c_he; 1310 int width = c2c_width(fmt, hpp, he->hists); 1311 char buf[10]; 1312 1313 c2c_he = container_of(he, struct c2c_hist_entry, he); 1314 1315 scnprintf(buf, 10, "%d", bitmap_weight(c2c_he->cpuset, c2c.cpus_cnt)); 1316 return scnprintf(hpp->buf, hpp->size, "%*s", width, buf); 1317 } 1318 1319 static int 1320 cl_idx_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1321 struct hist_entry *he) 1322 { 1323 struct c2c_hist_entry *c2c_he; 1324 int width = c2c_width(fmt, hpp, he->hists); 1325 char buf[10]; 1326 1327 c2c_he = container_of(he, struct c2c_hist_entry, he); 1328 1329 scnprintf(buf, 10, "%u", c2c_he->cacheline_idx); 1330 return scnprintf(hpp->buf, hpp->size, "%*s", width, buf); 1331 } 1332 1333 static int 1334 cl_idx_empty_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1335 struct hist_entry *he) 1336 { 1337 int width = c2c_width(fmt, hpp, he->hists); 1338 1339 return scnprintf(hpp->buf, hpp->size, "%*s", width, ""); 1340 } 1341 1342 #define HEADER_LOW(__h) \ 1343 { \ 1344 .line[1] = { \ 1345 .text = __h, \ 1346 }, \ 1347 } 1348 1349 #define HEADER_BOTH(__h0, __h1) \ 1350 { \ 1351 .line[0] = { \ 1352 .text = __h0, \ 1353 }, \ 1354 .line[1] = { \ 1355 .text = __h1, \ 1356 }, \ 1357 } 1358 1359 #define HEADER_SPAN(__h0, __h1, __s) \ 1360 { \ 1361 .line[0] = { \ 1362 .text = __h0, \ 1363 .span = __s, \ 1364 }, \ 1365 .line[1] = { \ 1366 .text = __h1, \ 1367 }, \ 1368 } 1369 1370 #define HEADER_SPAN_LOW(__h) \ 1371 { \ 1372 .line[1] = { \ 1373 .text = __h, \ 1374 }, \ 1375 } 1376 1377 static struct c2c_dimension dim_dcacheline = { 1378 .header = HEADER_SPAN("--- Cacheline ----", "Address", 2), 1379 .name = "dcacheline", 1380 .cmp = dcacheline_cmp, 1381 .entry = dcacheline_entry, 1382 .width = 18, 1383 }; 1384 1385 static struct c2c_dimension dim_dcacheline_node = { 1386 .header = HEADER_LOW("Node"), 1387 .name = "dcacheline_node", 1388 .cmp = empty_cmp, 1389 .entry = dcacheline_node_entry, 1390 .width = 4, 1391 }; 1392 1393 static struct c2c_dimension dim_dcacheline_count = { 1394 .header = HEADER_LOW("PA cnt"), 1395 .name = "dcacheline_count", 1396 .cmp = empty_cmp, 1397 .entry = dcacheline_node_count, 1398 .width = 6, 1399 }; 1400 1401 static struct c2c_header header_offset_tui = HEADER_SPAN("-----", "Off", 2); 1402 1403 static struct c2c_dimension dim_offset = { 1404 .header = HEADER_SPAN("--- Data address -", "Offset", 2), 1405 .name = "offset", 1406 .cmp = offset_cmp, 1407 .entry = offset_entry, 1408 .width = 18, 1409 }; 1410 1411 static struct c2c_dimension dim_offset_node = { 1412 .header = HEADER_LOW("Node"), 1413 .name = "offset_node", 1414 .cmp = empty_cmp, 1415 .entry = dcacheline_node_entry, 1416 .width = 4, 1417 }; 1418 1419 static struct c2c_dimension dim_iaddr = { 1420 .header = HEADER_LOW("Code address"), 1421 .name = "iaddr", 1422 .cmp = iaddr_cmp, 1423 .entry = iaddr_entry, 1424 .width = 18, 1425 }; 1426 1427 static struct c2c_dimension dim_tot_hitm = { 1428 .header = HEADER_SPAN("------- Load Hitm -------", "Total", 2), 1429 .name = "tot_hitm", 1430 .cmp = tot_hitm_cmp, 1431 .entry = tot_hitm_entry, 1432 .width = 7, 1433 }; 1434 1435 static struct c2c_dimension dim_lcl_hitm = { 1436 .header = HEADER_SPAN_LOW("LclHitm"), 1437 .name = "lcl_hitm", 1438 .cmp = lcl_hitm_cmp, 1439 .entry = lcl_hitm_entry, 1440 .width = 7, 1441 }; 1442 1443 static struct c2c_dimension dim_rmt_hitm = { 1444 .header = HEADER_SPAN_LOW("RmtHitm"), 1445 .name = "rmt_hitm", 1446 .cmp = rmt_hitm_cmp, 1447 .entry = rmt_hitm_entry, 1448 .width = 7, 1449 }; 1450 1451 static struct c2c_dimension dim_tot_peer = { 1452 .header = HEADER_SPAN("------- Load Peer -------", "Total", 2), 1453 .name = "tot_peer", 1454 .cmp = tot_peer_cmp, 1455 .entry = tot_peer_entry, 1456 .width = 7, 1457 }; 1458 1459 static struct c2c_dimension dim_lcl_peer = { 1460 .header = HEADER_SPAN_LOW("Local"), 1461 .name = "lcl_peer", 1462 .cmp = lcl_peer_cmp, 1463 .entry = lcl_peer_entry, 1464 .width = 7, 1465 }; 1466 1467 static struct c2c_dimension dim_rmt_peer = { 1468 .header = HEADER_SPAN_LOW("Remote"), 1469 .name = "rmt_peer", 1470 .cmp = rmt_peer_cmp, 1471 .entry = rmt_peer_entry, 1472 .width = 7, 1473 }; 1474 1475 static struct c2c_dimension dim_cl_rmt_hitm = { 1476 .header = HEADER_SPAN("----- HITM -----", "Rmt", 1), 1477 .name = "cl_rmt_hitm", 1478 .cmp = rmt_hitm_cmp, 1479 .entry = rmt_hitm_entry, 1480 .width = 7, 1481 }; 1482 1483 static struct c2c_dimension dim_cl_lcl_hitm = { 1484 .header = HEADER_SPAN_LOW("Lcl"), 1485 .name = "cl_lcl_hitm", 1486 .cmp = lcl_hitm_cmp, 1487 .entry = lcl_hitm_entry, 1488 .width = 7, 1489 }; 1490 1491 static struct c2c_dimension dim_cl_rmt_peer = { 1492 .header = HEADER_SPAN("----- Peer -----", "Rmt", 1), 1493 .name = "cl_rmt_peer", 1494 .cmp = rmt_peer_cmp, 1495 .entry = rmt_peer_entry, 1496 .width = 7, 1497 }; 1498 1499 static struct c2c_dimension dim_cl_lcl_peer = { 1500 .header = HEADER_SPAN_LOW("Lcl"), 1501 .name = "cl_lcl_peer", 1502 .cmp = lcl_peer_cmp, 1503 .entry = lcl_peer_entry, 1504 .width = 7, 1505 }; 1506 1507 static struct c2c_dimension dim_tot_stores = { 1508 .header = HEADER_BOTH("Total", "Stores"), 1509 .name = "tot_stores", 1510 .cmp = store_cmp, 1511 .entry = store_entry, 1512 .width = 7, 1513 }; 1514 1515 static struct c2c_dimension dim_stores_l1hit = { 1516 .header = HEADER_SPAN("--------- Stores --------", "L1Hit", 2), 1517 .name = "stores_l1hit", 1518 .cmp = st_l1hit_cmp, 1519 .entry = st_l1hit_entry, 1520 .width = 7, 1521 }; 1522 1523 static struct c2c_dimension dim_stores_l1miss = { 1524 .header = HEADER_SPAN_LOW("L1Miss"), 1525 .name = "stores_l1miss", 1526 .cmp = st_l1miss_cmp, 1527 .entry = st_l1miss_entry, 1528 .width = 7, 1529 }; 1530 1531 static struct c2c_dimension dim_stores_na = { 1532 .header = HEADER_SPAN_LOW("N/A"), 1533 .name = "stores_na", 1534 .cmp = st_na_cmp, 1535 .entry = st_na_entry, 1536 .width = 7, 1537 }; 1538 1539 static struct c2c_dimension dim_cl_stores_l1hit = { 1540 .header = HEADER_SPAN("------- Store Refs ------", "L1 Hit", 2), 1541 .name = "cl_stores_l1hit", 1542 .cmp = st_l1hit_cmp, 1543 .entry = st_l1hit_entry, 1544 .width = 7, 1545 }; 1546 1547 static struct c2c_dimension dim_cl_stores_l1miss = { 1548 .header = HEADER_SPAN_LOW("L1 Miss"), 1549 .name = "cl_stores_l1miss", 1550 .cmp = st_l1miss_cmp, 1551 .entry = st_l1miss_entry, 1552 .width = 7, 1553 }; 1554 1555 static struct c2c_dimension dim_cl_stores_na = { 1556 .header = HEADER_SPAN_LOW("N/A"), 1557 .name = "cl_stores_na", 1558 .cmp = st_na_cmp, 1559 .entry = st_na_entry, 1560 .width = 7, 1561 }; 1562 1563 static struct c2c_dimension dim_ld_fbhit = { 1564 .header = HEADER_SPAN("----- Core Load Hit -----", "FB", 2), 1565 .name = "ld_fbhit", 1566 .cmp = ld_fbhit_cmp, 1567 .entry = ld_fbhit_entry, 1568 .width = 7, 1569 }; 1570 1571 static struct c2c_dimension dim_ld_l1hit = { 1572 .header = HEADER_SPAN_LOW("L1"), 1573 .name = "ld_l1hit", 1574 .cmp = ld_l1hit_cmp, 1575 .entry = ld_l1hit_entry, 1576 .width = 7, 1577 }; 1578 1579 static struct c2c_dimension dim_ld_l2hit = { 1580 .header = HEADER_SPAN_LOW("L2"), 1581 .name = "ld_l2hit", 1582 .cmp = ld_l2hit_cmp, 1583 .entry = ld_l2hit_entry, 1584 .width = 7, 1585 }; 1586 1587 static struct c2c_dimension dim_ld_llchit = { 1588 .header = HEADER_SPAN("- LLC Load Hit --", "LclHit", 1), 1589 .name = "ld_lclhit", 1590 .cmp = ld_llchit_cmp, 1591 .entry = ld_llchit_entry, 1592 .width = 8, 1593 }; 1594 1595 static struct c2c_dimension dim_ld_rmthit = { 1596 .header = HEADER_SPAN("- RMT Load Hit --", "RmtHit", 1), 1597 .name = "ld_rmthit", 1598 .cmp = rmt_hit_cmp, 1599 .entry = rmt_hit_entry, 1600 .width = 8, 1601 }; 1602 1603 static struct c2c_dimension dim_tot_recs = { 1604 .header = HEADER_BOTH("Total", "records"), 1605 .name = "tot_recs", 1606 .cmp = tot_recs_cmp, 1607 .entry = tot_recs_entry, 1608 .width = 7, 1609 }; 1610 1611 static struct c2c_dimension dim_tot_loads = { 1612 .header = HEADER_BOTH("Total", "Loads"), 1613 .name = "tot_loads", 1614 .cmp = tot_loads_cmp, 1615 .entry = tot_loads_entry, 1616 .width = 7, 1617 }; 1618 1619 static struct c2c_header percent_costly_snoop_header[] = { 1620 [DISPLAY_LCL_HITM] = HEADER_BOTH("Lcl", "Hitm"), 1621 [DISPLAY_RMT_HITM] = HEADER_BOTH("Rmt", "Hitm"), 1622 [DISPLAY_TOT_HITM] = HEADER_BOTH("Tot", "Hitm"), 1623 [DISPLAY_SNP_PEER] = HEADER_BOTH("Peer", "Snoop"), 1624 }; 1625 1626 static struct c2c_dimension dim_percent_costly_snoop = { 1627 .name = "percent_costly_snoop", 1628 .cmp = percent_costly_snoop_cmp, 1629 .entry = percent_costly_snoop_entry, 1630 .color = percent_costly_snoop_color, 1631 .width = 7, 1632 }; 1633 1634 static struct c2c_dimension dim_percent_rmt_hitm = { 1635 .header = HEADER_SPAN("----- HITM -----", "RmtHitm", 1), 1636 .name = "percent_rmt_hitm", 1637 .cmp = percent_rmt_hitm_cmp, 1638 .entry = percent_rmt_hitm_entry, 1639 .color = percent_rmt_hitm_color, 1640 .width = 7, 1641 }; 1642 1643 static struct c2c_dimension dim_percent_lcl_hitm = { 1644 .header = HEADER_SPAN_LOW("LclHitm"), 1645 .name = "percent_lcl_hitm", 1646 .cmp = percent_lcl_hitm_cmp, 1647 .entry = percent_lcl_hitm_entry, 1648 .color = percent_lcl_hitm_color, 1649 .width = 7, 1650 }; 1651 1652 static struct c2c_dimension dim_percent_rmt_peer = { 1653 .header = HEADER_SPAN("-- Peer Snoop --", "Rmt", 1), 1654 .name = "percent_rmt_peer", 1655 .cmp = percent_rmt_peer_cmp, 1656 .entry = percent_rmt_peer_entry, 1657 .color = percent_rmt_peer_color, 1658 .width = 7, 1659 }; 1660 1661 static struct c2c_dimension dim_percent_lcl_peer = { 1662 .header = HEADER_SPAN_LOW("Lcl"), 1663 .name = "percent_lcl_peer", 1664 .cmp = percent_lcl_peer_cmp, 1665 .entry = percent_lcl_peer_entry, 1666 .color = percent_lcl_peer_color, 1667 .width = 7, 1668 }; 1669 1670 static struct c2c_dimension dim_percent_stores_l1hit = { 1671 .header = HEADER_SPAN("------- Store Refs ------", "L1 Hit", 2), 1672 .name = "percent_stores_l1hit", 1673 .cmp = percent_stores_l1hit_cmp, 1674 .entry = percent_stores_l1hit_entry, 1675 .color = percent_stores_l1hit_color, 1676 .width = 7, 1677 }; 1678 1679 static struct c2c_dimension dim_percent_stores_l1miss = { 1680 .header = HEADER_SPAN_LOW("L1 Miss"), 1681 .name = "percent_stores_l1miss", 1682 .cmp = percent_stores_l1miss_cmp, 1683 .entry = percent_stores_l1miss_entry, 1684 .color = percent_stores_l1miss_color, 1685 .width = 7, 1686 }; 1687 1688 static struct c2c_dimension dim_percent_stores_na = { 1689 .header = HEADER_SPAN_LOW("N/A"), 1690 .name = "percent_stores_na", 1691 .cmp = percent_stores_na_cmp, 1692 .entry = percent_stores_na_entry, 1693 .color = percent_stores_na_color, 1694 .width = 7, 1695 }; 1696 1697 static struct c2c_dimension dim_dram_lcl = { 1698 .header = HEADER_SPAN("--- Load Dram ----", "Lcl", 1), 1699 .name = "dram_lcl", 1700 .cmp = lcl_dram_cmp, 1701 .entry = lcl_dram_entry, 1702 .width = 8, 1703 }; 1704 1705 static struct c2c_dimension dim_dram_rmt = { 1706 .header = HEADER_SPAN_LOW("Rmt"), 1707 .name = "dram_rmt", 1708 .cmp = rmt_dram_cmp, 1709 .entry = rmt_dram_entry, 1710 .width = 8, 1711 }; 1712 1713 static struct c2c_dimension dim_pid = { 1714 .header = HEADER_LOW("Pid"), 1715 .name = "pid", 1716 .cmp = pid_cmp, 1717 .entry = pid_entry, 1718 .width = 7, 1719 }; 1720 1721 static struct c2c_dimension dim_tid = { 1722 .header = HEADER_LOW("Tid"), 1723 .name = "tid", 1724 .se = &sort_thread, 1725 }; 1726 1727 static struct c2c_dimension dim_symbol = { 1728 .name = "symbol", 1729 .se = &sort_sym, 1730 }; 1731 1732 static struct c2c_dimension dim_dso = { 1733 .header = HEADER_BOTH("Shared", "Object"), 1734 .name = "dso", 1735 .se = &sort_dso, 1736 }; 1737 1738 static struct c2c_dimension dim_node = { 1739 .name = "node", 1740 .cmp = empty_cmp, 1741 .entry = node_entry, 1742 .width = 4, 1743 }; 1744 1745 static struct c2c_dimension dim_mean_rmt = { 1746 .header = HEADER_SPAN("---------- cycles ----------", "rmt hitm", 2), 1747 .name = "mean_rmt", 1748 .cmp = empty_cmp, 1749 .entry = mean_rmt_entry, 1750 .width = 8, 1751 }; 1752 1753 static struct c2c_dimension dim_mean_lcl = { 1754 .header = HEADER_SPAN_LOW("lcl hitm"), 1755 .name = "mean_lcl", 1756 .cmp = empty_cmp, 1757 .entry = mean_lcl_entry, 1758 .width = 8, 1759 }; 1760 1761 static struct c2c_dimension dim_mean_load = { 1762 .header = HEADER_SPAN_LOW("load"), 1763 .name = "mean_load", 1764 .cmp = empty_cmp, 1765 .entry = mean_load_entry, 1766 .width = 8, 1767 }; 1768 1769 static struct c2c_dimension dim_mean_rmt_peer = { 1770 .header = HEADER_SPAN("---------- cycles ----------", "rmt peer", 2), 1771 .name = "mean_rmt_peer", 1772 .cmp = empty_cmp, 1773 .entry = mean_rmt_peer_entry, 1774 .width = 8, 1775 }; 1776 1777 static struct c2c_dimension dim_mean_lcl_peer = { 1778 .header = HEADER_SPAN_LOW("lcl peer"), 1779 .name = "mean_lcl_peer", 1780 .cmp = empty_cmp, 1781 .entry = mean_lcl_peer_entry, 1782 .width = 8, 1783 }; 1784 1785 static struct c2c_dimension dim_cpucnt = { 1786 .header = HEADER_BOTH("cpu", "cnt"), 1787 .name = "cpucnt", 1788 .cmp = empty_cmp, 1789 .entry = cpucnt_entry, 1790 .width = 8, 1791 }; 1792 1793 static struct c2c_dimension dim_srcline = { 1794 .name = "cl_srcline", 1795 .se = &sort_srcline, 1796 }; 1797 1798 static struct c2c_dimension dim_dcacheline_idx = { 1799 .header = HEADER_LOW("Index"), 1800 .name = "cl_idx", 1801 .cmp = empty_cmp, 1802 .entry = cl_idx_entry, 1803 .width = 5, 1804 }; 1805 1806 static struct c2c_dimension dim_dcacheline_num = { 1807 .header = HEADER_LOW("Num"), 1808 .name = "cl_num", 1809 .cmp = empty_cmp, 1810 .entry = cl_idx_entry, 1811 .width = 5, 1812 }; 1813 1814 static struct c2c_dimension dim_dcacheline_num_empty = { 1815 .header = HEADER_LOW("Num"), 1816 .name = "cl_num_empty", 1817 .cmp = empty_cmp, 1818 .entry = cl_idx_empty_entry, 1819 .width = 5, 1820 }; 1821 1822 static struct c2c_dimension *dimensions[] = { 1823 &dim_dcacheline, 1824 &dim_dcacheline_node, 1825 &dim_dcacheline_count, 1826 &dim_offset, 1827 &dim_offset_node, 1828 &dim_iaddr, 1829 &dim_tot_hitm, 1830 &dim_lcl_hitm, 1831 &dim_rmt_hitm, 1832 &dim_tot_peer, 1833 &dim_lcl_peer, 1834 &dim_rmt_peer, 1835 &dim_cl_lcl_hitm, 1836 &dim_cl_rmt_hitm, 1837 &dim_cl_lcl_peer, 1838 &dim_cl_rmt_peer, 1839 &dim_tot_stores, 1840 &dim_stores_l1hit, 1841 &dim_stores_l1miss, 1842 &dim_stores_na, 1843 &dim_cl_stores_l1hit, 1844 &dim_cl_stores_l1miss, 1845 &dim_cl_stores_na, 1846 &dim_ld_fbhit, 1847 &dim_ld_l1hit, 1848 &dim_ld_l2hit, 1849 &dim_ld_llchit, 1850 &dim_ld_rmthit, 1851 &dim_tot_recs, 1852 &dim_tot_loads, 1853 &dim_percent_costly_snoop, 1854 &dim_percent_rmt_hitm, 1855 &dim_percent_lcl_hitm, 1856 &dim_percent_rmt_peer, 1857 &dim_percent_lcl_peer, 1858 &dim_percent_stores_l1hit, 1859 &dim_percent_stores_l1miss, 1860 &dim_percent_stores_na, 1861 &dim_dram_lcl, 1862 &dim_dram_rmt, 1863 &dim_pid, 1864 &dim_tid, 1865 &dim_symbol, 1866 &dim_dso, 1867 &dim_node, 1868 &dim_mean_rmt, 1869 &dim_mean_lcl, 1870 &dim_mean_rmt_peer, 1871 &dim_mean_lcl_peer, 1872 &dim_mean_load, 1873 &dim_cpucnt, 1874 &dim_srcline, 1875 &dim_dcacheline_idx, 1876 &dim_dcacheline_num, 1877 &dim_dcacheline_num_empty, 1878 NULL, 1879 }; 1880 1881 static void fmt_free(struct perf_hpp_fmt *fmt) 1882 { 1883 struct c2c_fmt *c2c_fmt; 1884 1885 c2c_fmt = container_of(fmt, struct c2c_fmt, fmt); 1886 free(c2c_fmt); 1887 } 1888 1889 static bool fmt_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b) 1890 { 1891 struct c2c_fmt *c2c_a = container_of(a, struct c2c_fmt, fmt); 1892 struct c2c_fmt *c2c_b = container_of(b, struct c2c_fmt, fmt); 1893 1894 return c2c_a->dim == c2c_b->dim; 1895 } 1896 1897 static struct c2c_dimension *get_dimension(const char *name) 1898 { 1899 unsigned int i; 1900 1901 for (i = 0; dimensions[i]; i++) { 1902 struct c2c_dimension *dim = dimensions[i]; 1903 1904 if (!strcmp(dim->name, name)) 1905 return dim; 1906 } 1907 1908 return NULL; 1909 } 1910 1911 static int c2c_se_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1912 struct hist_entry *he) 1913 { 1914 struct c2c_fmt *c2c_fmt = container_of(fmt, struct c2c_fmt, fmt); 1915 struct c2c_dimension *dim = c2c_fmt->dim; 1916 size_t len = fmt->user_len; 1917 1918 if (!len) { 1919 len = hists__col_len(he->hists, dim->se->se_width_idx); 1920 1921 if (dim == &dim_symbol || dim == &dim_srcline) 1922 len = symbol_width(he->hists, dim->se); 1923 } 1924 1925 return dim->se->se_snprintf(he, hpp->buf, hpp->size, len); 1926 } 1927 1928 static int64_t c2c_se_cmp(struct perf_hpp_fmt *fmt, 1929 struct hist_entry *a, struct hist_entry *b) 1930 { 1931 struct c2c_fmt *c2c_fmt = container_of(fmt, struct c2c_fmt, fmt); 1932 struct c2c_dimension *dim = c2c_fmt->dim; 1933 1934 return dim->se->se_cmp(a, b); 1935 } 1936 1937 static int64_t c2c_se_collapse(struct perf_hpp_fmt *fmt, 1938 struct hist_entry *a, struct hist_entry *b) 1939 { 1940 struct c2c_fmt *c2c_fmt = container_of(fmt, struct c2c_fmt, fmt); 1941 struct c2c_dimension *dim = c2c_fmt->dim; 1942 int64_t (*collapse_fn)(struct hist_entry *, struct hist_entry *); 1943 1944 collapse_fn = dim->se->se_collapse ?: dim->se->se_cmp; 1945 return collapse_fn(a, b); 1946 } 1947 1948 static struct c2c_fmt *get_format(const char *name) 1949 { 1950 struct c2c_dimension *dim = get_dimension(name); 1951 struct c2c_fmt *c2c_fmt; 1952 struct perf_hpp_fmt *fmt; 1953 1954 if (!dim) 1955 return NULL; 1956 1957 c2c_fmt = zalloc(sizeof(*c2c_fmt)); 1958 if (!c2c_fmt) 1959 return NULL; 1960 1961 c2c_fmt->dim = dim; 1962 1963 fmt = &c2c_fmt->fmt; 1964 INIT_LIST_HEAD(&fmt->list); 1965 INIT_LIST_HEAD(&fmt->sort_list); 1966 1967 fmt->cmp = dim->se ? c2c_se_cmp : dim->cmp; 1968 fmt->sort = dim->se ? c2c_se_cmp : dim->cmp; 1969 fmt->color = dim->se ? NULL : dim->color; 1970 fmt->entry = dim->se ? c2c_se_entry : dim->entry; 1971 fmt->header = c2c_header; 1972 fmt->width = c2c_width; 1973 fmt->collapse = dim->se ? c2c_se_collapse : dim->cmp; 1974 fmt->equal = fmt_equal; 1975 fmt->free = fmt_free; 1976 1977 return c2c_fmt; 1978 } 1979 1980 static int c2c_hists__init_output(struct perf_hpp_list *hpp_list, char *name) 1981 { 1982 struct c2c_fmt *c2c_fmt = get_format(name); 1983 1984 if (!c2c_fmt) { 1985 reset_dimensions(); 1986 return output_field_add(hpp_list, name); 1987 } 1988 1989 perf_hpp_list__column_register(hpp_list, &c2c_fmt->fmt); 1990 return 0; 1991 } 1992 1993 static int c2c_hists__init_sort(struct perf_hpp_list *hpp_list, char *name) 1994 { 1995 struct c2c_fmt *c2c_fmt = get_format(name); 1996 struct c2c_dimension *dim; 1997 1998 if (!c2c_fmt) { 1999 reset_dimensions(); 2000 return sort_dimension__add(hpp_list, name, NULL, 0); 2001 } 2002 2003 dim = c2c_fmt->dim; 2004 if (dim == &dim_dso) 2005 hpp_list->dso = 1; 2006 2007 perf_hpp_list__register_sort_field(hpp_list, &c2c_fmt->fmt); 2008 return 0; 2009 } 2010 2011 #define PARSE_LIST(_list, _fn) \ 2012 do { \ 2013 char *tmp, *tok; \ 2014 ret = 0; \ 2015 \ 2016 if (!_list) \ 2017 break; \ 2018 \ 2019 for (tok = strtok_r((char *)_list, ", ", &tmp); \ 2020 tok; tok = strtok_r(NULL, ", ", &tmp)) { \ 2021 ret = _fn(hpp_list, tok); \ 2022 if (ret == -EINVAL) { \ 2023 pr_err("Invalid --fields key: `%s'", tok); \ 2024 break; \ 2025 } else if (ret == -ESRCH) { \ 2026 pr_err("Unknown --fields key: `%s'", tok); \ 2027 break; \ 2028 } \ 2029 } \ 2030 } while (0) 2031 2032 static int hpp_list__parse(struct perf_hpp_list *hpp_list, 2033 const char *output_, 2034 const char *sort_) 2035 { 2036 char *output = output_ ? strdup(output_) : NULL; 2037 char *sort = sort_ ? strdup(sort_) : NULL; 2038 int ret; 2039 2040 PARSE_LIST(output, c2c_hists__init_output); 2041 PARSE_LIST(sort, c2c_hists__init_sort); 2042 2043 /* copy sort keys to output fields */ 2044 perf_hpp__setup_output_field(hpp_list); 2045 2046 /* 2047 * We dont need other sorting keys other than those 2048 * we already specified. It also really slows down 2049 * the processing a lot with big number of output 2050 * fields, so switching this off for c2c. 2051 */ 2052 2053 #if 0 2054 /* and then copy output fields to sort keys */ 2055 perf_hpp__append_sort_keys(&hists->list); 2056 #endif 2057 2058 free(output); 2059 free(sort); 2060 return ret; 2061 } 2062 2063 static int c2c_hists__init(struct c2c_hists *hists, 2064 const char *sort, 2065 int nr_header_lines) 2066 { 2067 __hists__init(&hists->hists, &hists->list); 2068 2069 /* 2070 * Initialize only with sort fields, we need to resort 2071 * later anyway, and that's where we add output fields 2072 * as well. 2073 */ 2074 perf_hpp_list__init(&hists->list); 2075 2076 /* Overload number of header lines.*/ 2077 hists->list.nr_header_lines = nr_header_lines; 2078 2079 return hpp_list__parse(&hists->list, NULL, sort); 2080 } 2081 2082 static int c2c_hists__reinit(struct c2c_hists *c2c_hists, 2083 const char *output, 2084 const char *sort) 2085 { 2086 perf_hpp__reset_output_field(&c2c_hists->list); 2087 return hpp_list__parse(&c2c_hists->list, output, sort); 2088 } 2089 2090 #define DISPLAY_LINE_LIMIT 0.001 2091 2092 static u8 filter_display(u32 val, u32 sum) 2093 { 2094 if (sum == 0 || ((double)val / sum) < DISPLAY_LINE_LIMIT) 2095 return HIST_FILTER__C2C; 2096 2097 return 0; 2098 } 2099 2100 static bool he__display(struct hist_entry *he, struct c2c_stats *stats) 2101 { 2102 struct c2c_hist_entry *c2c_he; 2103 2104 if (c2c.show_all) 2105 return true; 2106 2107 c2c_he = container_of(he, struct c2c_hist_entry, he); 2108 2109 switch (c2c.display) { 2110 case DISPLAY_LCL_HITM: 2111 he->filtered = filter_display(c2c_he->stats.lcl_hitm, 2112 stats->lcl_hitm); 2113 break; 2114 case DISPLAY_RMT_HITM: 2115 he->filtered = filter_display(c2c_he->stats.rmt_hitm, 2116 stats->rmt_hitm); 2117 break; 2118 case DISPLAY_TOT_HITM: 2119 he->filtered = filter_display(c2c_he->stats.tot_hitm, 2120 stats->tot_hitm); 2121 break; 2122 case DISPLAY_SNP_PEER: 2123 he->filtered = filter_display(c2c_he->stats.tot_peer, 2124 stats->tot_peer); 2125 break; 2126 default: 2127 break; 2128 } 2129 2130 return he->filtered == 0; 2131 } 2132 2133 static inline bool is_valid_hist_entry(struct hist_entry *he) 2134 { 2135 struct c2c_hist_entry *c2c_he; 2136 bool has_record = false; 2137 2138 c2c_he = container_of(he, struct c2c_hist_entry, he); 2139 2140 /* It's a valid entry if contains stores */ 2141 if (c2c_he->stats.store) 2142 return true; 2143 2144 switch (c2c.display) { 2145 case DISPLAY_LCL_HITM: 2146 has_record = !!c2c_he->stats.lcl_hitm; 2147 break; 2148 case DISPLAY_RMT_HITM: 2149 has_record = !!c2c_he->stats.rmt_hitm; 2150 break; 2151 case DISPLAY_TOT_HITM: 2152 has_record = !!c2c_he->stats.tot_hitm; 2153 break; 2154 case DISPLAY_SNP_PEER: 2155 has_record = !!c2c_he->stats.tot_peer; 2156 default: 2157 break; 2158 } 2159 2160 return has_record; 2161 } 2162 2163 static void set_node_width(struct c2c_hist_entry *c2c_he, int len) 2164 { 2165 struct c2c_dimension *dim; 2166 2167 dim = &c2c.hists == c2c_he->hists ? 2168 &dim_dcacheline_node : &dim_offset_node; 2169 2170 if (len > dim->width) 2171 dim->width = len; 2172 } 2173 2174 static int set_nodestr(struct c2c_hist_entry *c2c_he) 2175 { 2176 char buf[30]; 2177 int len; 2178 2179 if (c2c_he->nodestr) 2180 return 0; 2181 2182 if (!bitmap_empty(c2c_he->nodeset, c2c.nodes_cnt)) { 2183 len = bitmap_scnprintf(c2c_he->nodeset, c2c.nodes_cnt, 2184 buf, sizeof(buf)); 2185 } else { 2186 len = scnprintf(buf, sizeof(buf), "N/A"); 2187 } 2188 2189 set_node_width(c2c_he, len); 2190 c2c_he->nodestr = strdup(buf); 2191 return c2c_he->nodestr ? 0 : -ENOMEM; 2192 } 2193 2194 static void calc_width(struct c2c_hist_entry *c2c_he) 2195 { 2196 struct c2c_hists *c2c_hists; 2197 2198 c2c_hists = container_of(c2c_he->he.hists, struct c2c_hists, hists); 2199 hists__calc_col_len(&c2c_hists->hists, &c2c_he->he); 2200 set_nodestr(c2c_he); 2201 } 2202 2203 static int filter_cb(struct hist_entry *he, void *arg __maybe_unused) 2204 { 2205 struct c2c_hist_entry *c2c_he; 2206 2207 c2c_he = container_of(he, struct c2c_hist_entry, he); 2208 2209 if (c2c.show_src && !he->srcline) 2210 he->srcline = hist_entry__srcline(he); 2211 2212 calc_width(c2c_he); 2213 2214 if (!is_valid_hist_entry(he)) 2215 he->filtered = HIST_FILTER__C2C; 2216 2217 return 0; 2218 } 2219 2220 static int resort_cl_cb(struct hist_entry *he, void *arg __maybe_unused) 2221 { 2222 struct c2c_hist_entry *c2c_he; 2223 struct c2c_hists *c2c_hists; 2224 bool display = he__display(he, &c2c.shared_clines_stats); 2225 2226 c2c_he = container_of(he, struct c2c_hist_entry, he); 2227 c2c_hists = c2c_he->hists; 2228 2229 if (display && c2c_hists) { 2230 static unsigned int idx; 2231 2232 c2c_he->cacheline_idx = idx++; 2233 calc_width(c2c_he); 2234 2235 c2c_hists__reinit(c2c_hists, c2c.cl_output, c2c.cl_resort); 2236 2237 hists__collapse_resort(&c2c_hists->hists, NULL); 2238 hists__output_resort_cb(&c2c_hists->hists, NULL, filter_cb); 2239 } 2240 2241 return 0; 2242 } 2243 2244 static struct c2c_header header_node_0 = HEADER_LOW("Node"); 2245 static struct c2c_header header_node_1_hitms_stores = 2246 HEADER_LOW("Node{cpus %hitms %stores}"); 2247 static struct c2c_header header_node_1_peers_stores = 2248 HEADER_LOW("Node{cpus %peers %stores}"); 2249 static struct c2c_header header_node_2 = HEADER_LOW("Node{cpu list}"); 2250 2251 static void setup_nodes_header(void) 2252 { 2253 switch (c2c.node_info) { 2254 case 0: 2255 dim_node.header = header_node_0; 2256 break; 2257 case 1: 2258 if (c2c.display == DISPLAY_SNP_PEER) 2259 dim_node.header = header_node_1_peers_stores; 2260 else 2261 dim_node.header = header_node_1_hitms_stores; 2262 break; 2263 case 2: 2264 dim_node.header = header_node_2; 2265 break; 2266 default: 2267 break; 2268 } 2269 2270 return; 2271 } 2272 2273 static int setup_nodes(struct perf_session *session) 2274 { 2275 struct numa_node *n; 2276 unsigned long **nodes; 2277 int node, idx; 2278 struct perf_cpu cpu; 2279 int *cpu2node; 2280 2281 if (c2c.node_info > 2) 2282 c2c.node_info = 2; 2283 2284 c2c.nodes_cnt = session->header.env.nr_numa_nodes; 2285 c2c.cpus_cnt = session->header.env.nr_cpus_avail; 2286 2287 n = session->header.env.numa_nodes; 2288 if (!n) 2289 return -EINVAL; 2290 2291 nodes = zalloc(sizeof(unsigned long *) * c2c.nodes_cnt); 2292 if (!nodes) 2293 return -ENOMEM; 2294 2295 c2c.nodes = nodes; 2296 2297 cpu2node = zalloc(sizeof(int) * c2c.cpus_cnt); 2298 if (!cpu2node) 2299 return -ENOMEM; 2300 2301 for (idx = 0; idx < c2c.cpus_cnt; idx++) 2302 cpu2node[idx] = -1; 2303 2304 c2c.cpu2node = cpu2node; 2305 2306 for (node = 0; node < c2c.nodes_cnt; node++) { 2307 struct perf_cpu_map *map = n[node].map; 2308 unsigned long *set; 2309 2310 set = bitmap_zalloc(c2c.cpus_cnt); 2311 if (!set) 2312 return -ENOMEM; 2313 2314 nodes[node] = set; 2315 2316 /* empty node, skip */ 2317 if (perf_cpu_map__empty(map)) 2318 continue; 2319 2320 perf_cpu_map__for_each_cpu(cpu, idx, map) { 2321 set_bit(cpu.cpu, set); 2322 2323 if (WARN_ONCE(cpu2node[cpu.cpu] != -1, "node/cpu topology bug")) 2324 return -EINVAL; 2325 2326 cpu2node[cpu.cpu] = node; 2327 } 2328 } 2329 2330 setup_nodes_header(); 2331 return 0; 2332 } 2333 2334 #define HAS_HITMS(__h) ((__h)->stats.lcl_hitm || (__h)->stats.rmt_hitm) 2335 #define HAS_PEER(__h) ((__h)->stats.lcl_peer || (__h)->stats.rmt_peer) 2336 2337 static int resort_shared_cl_cb(struct hist_entry *he, void *arg __maybe_unused) 2338 { 2339 struct c2c_hist_entry *c2c_he; 2340 c2c_he = container_of(he, struct c2c_hist_entry, he); 2341 2342 if (HAS_HITMS(c2c_he) || HAS_PEER(c2c_he)) { 2343 c2c.shared_clines++; 2344 c2c_add_stats(&c2c.shared_clines_stats, &c2c_he->stats); 2345 } 2346 2347 return 0; 2348 } 2349 2350 static int hists__iterate_cb(struct hists *hists, hists__resort_cb_t cb) 2351 { 2352 struct rb_node *next = rb_first_cached(&hists->entries); 2353 int ret = 0; 2354 2355 while (next) { 2356 struct hist_entry *he; 2357 2358 he = rb_entry(next, struct hist_entry, rb_node); 2359 ret = cb(he, NULL); 2360 if (ret) 2361 break; 2362 next = rb_next(&he->rb_node); 2363 } 2364 2365 return ret; 2366 } 2367 2368 static void print_c2c__display_stats(FILE *out) 2369 { 2370 int llc_misses; 2371 struct c2c_stats *stats = &c2c.hists.stats; 2372 2373 llc_misses = stats->lcl_dram + 2374 stats->rmt_dram + 2375 stats->rmt_hit + 2376 stats->rmt_hitm; 2377 2378 fprintf(out, "=================================================\n"); 2379 fprintf(out, " Trace Event Information \n"); 2380 fprintf(out, "=================================================\n"); 2381 fprintf(out, " Total records : %10d\n", stats->nr_entries); 2382 fprintf(out, " Locked Load/Store Operations : %10d\n", stats->locks); 2383 fprintf(out, " Load Operations : %10d\n", stats->load); 2384 fprintf(out, " Loads - uncacheable : %10d\n", stats->ld_uncache); 2385 fprintf(out, " Loads - IO : %10d\n", stats->ld_io); 2386 fprintf(out, " Loads - Miss : %10d\n", stats->ld_miss); 2387 fprintf(out, " Loads - no mapping : %10d\n", stats->ld_noadrs); 2388 fprintf(out, " Load Fill Buffer Hit : %10d\n", stats->ld_fbhit); 2389 fprintf(out, " Load L1D hit : %10d\n", stats->ld_l1hit); 2390 fprintf(out, " Load L2D hit : %10d\n", stats->ld_l2hit); 2391 fprintf(out, " Load LLC hit : %10d\n", stats->ld_llchit + stats->lcl_hitm); 2392 fprintf(out, " Load Local HITM : %10d\n", stats->lcl_hitm); 2393 fprintf(out, " Load Remote HITM : %10d\n", stats->rmt_hitm); 2394 fprintf(out, " Load Remote HIT : %10d\n", stats->rmt_hit); 2395 fprintf(out, " Load Local DRAM : %10d\n", stats->lcl_dram); 2396 fprintf(out, " Load Remote DRAM : %10d\n", stats->rmt_dram); 2397 fprintf(out, " Load MESI State Exclusive : %10d\n", stats->ld_excl); 2398 fprintf(out, " Load MESI State Shared : %10d\n", stats->ld_shared); 2399 fprintf(out, " Load LLC Misses : %10d\n", llc_misses); 2400 fprintf(out, " Load access blocked by data : %10d\n", stats->blk_data); 2401 fprintf(out, " Load access blocked by address : %10d\n", stats->blk_addr); 2402 fprintf(out, " Load HIT Local Peer : %10d\n", stats->lcl_peer); 2403 fprintf(out, " Load HIT Remote Peer : %10d\n", stats->rmt_peer); 2404 fprintf(out, " LLC Misses to Local DRAM : %10.1f%%\n", ((double)stats->lcl_dram/(double)llc_misses) * 100.); 2405 fprintf(out, " LLC Misses to Remote DRAM : %10.1f%%\n", ((double)stats->rmt_dram/(double)llc_misses) * 100.); 2406 fprintf(out, " LLC Misses to Remote cache (HIT) : %10.1f%%\n", ((double)stats->rmt_hit /(double)llc_misses) * 100.); 2407 fprintf(out, " LLC Misses to Remote cache (HITM) : %10.1f%%\n", ((double)stats->rmt_hitm/(double)llc_misses) * 100.); 2408 fprintf(out, " Store Operations : %10d\n", stats->store); 2409 fprintf(out, " Store - uncacheable : %10d\n", stats->st_uncache); 2410 fprintf(out, " Store - no mapping : %10d\n", stats->st_noadrs); 2411 fprintf(out, " Store L1D Hit : %10d\n", stats->st_l1hit); 2412 fprintf(out, " Store L1D Miss : %10d\n", stats->st_l1miss); 2413 fprintf(out, " Store No available memory level : %10d\n", stats->st_na); 2414 fprintf(out, " No Page Map Rejects : %10d\n", stats->nomap); 2415 fprintf(out, " Unable to parse data source : %10d\n", stats->noparse); 2416 } 2417 2418 static void print_shared_cacheline_info(FILE *out) 2419 { 2420 struct c2c_stats *stats = &c2c.shared_clines_stats; 2421 int hitm_cnt = stats->lcl_hitm + stats->rmt_hitm; 2422 2423 fprintf(out, "=================================================\n"); 2424 fprintf(out, " Global Shared Cache Line Event Information \n"); 2425 fprintf(out, "=================================================\n"); 2426 fprintf(out, " Total Shared Cache Lines : %10d\n", c2c.shared_clines); 2427 fprintf(out, " Load HITs on shared lines : %10d\n", stats->load); 2428 fprintf(out, " Fill Buffer Hits on shared lines : %10d\n", stats->ld_fbhit); 2429 fprintf(out, " L1D hits on shared lines : %10d\n", stats->ld_l1hit); 2430 fprintf(out, " L2D hits on shared lines : %10d\n", stats->ld_l2hit); 2431 fprintf(out, " LLC hits on shared lines : %10d\n", stats->ld_llchit + stats->lcl_hitm); 2432 fprintf(out, " Load hits on peer cache or nodes : %10d\n", stats->lcl_peer + stats->rmt_peer); 2433 fprintf(out, " Locked Access on shared lines : %10d\n", stats->locks); 2434 fprintf(out, " Blocked Access on shared lines : %10d\n", stats->blk_data + stats->blk_addr); 2435 fprintf(out, " Store HITs on shared lines : %10d\n", stats->store); 2436 fprintf(out, " Store L1D hits on shared lines : %10d\n", stats->st_l1hit); 2437 fprintf(out, " Store No available memory level : %10d\n", stats->st_na); 2438 fprintf(out, " Total Merged records : %10d\n", hitm_cnt + stats->store); 2439 } 2440 2441 static void print_cacheline(struct c2c_hists *c2c_hists, 2442 struct hist_entry *he_cl, 2443 struct perf_hpp_list *hpp_list, 2444 FILE *out) 2445 { 2446 char bf[1000]; 2447 struct perf_hpp hpp = { 2448 .buf = bf, 2449 .size = 1000, 2450 }; 2451 static bool once; 2452 2453 if (!once) { 2454 hists__fprintf_headers(&c2c_hists->hists, out); 2455 once = true; 2456 } else { 2457 fprintf(out, "\n"); 2458 } 2459 2460 fprintf(out, " ----------------------------------------------------------------------\n"); 2461 __hist_entry__snprintf(he_cl, &hpp, hpp_list); 2462 fprintf(out, "%s\n", bf); 2463 fprintf(out, " ----------------------------------------------------------------------\n"); 2464 2465 hists__fprintf(&c2c_hists->hists, false, 0, 0, 0, out, false); 2466 } 2467 2468 static void print_pareto(FILE *out) 2469 { 2470 struct perf_hpp_list hpp_list; 2471 struct rb_node *nd; 2472 int ret; 2473 const char *cl_output; 2474 2475 if (c2c.display != DISPLAY_SNP_PEER) 2476 cl_output = "cl_num," 2477 "cl_rmt_hitm," 2478 "cl_lcl_hitm," 2479 "cl_stores_l1hit," 2480 "cl_stores_l1miss," 2481 "cl_stores_na," 2482 "dcacheline"; 2483 else 2484 cl_output = "cl_num," 2485 "cl_rmt_peer," 2486 "cl_lcl_peer," 2487 "cl_stores_l1hit," 2488 "cl_stores_l1miss," 2489 "cl_stores_na," 2490 "dcacheline"; 2491 2492 perf_hpp_list__init(&hpp_list); 2493 ret = hpp_list__parse(&hpp_list, cl_output, NULL); 2494 2495 if (WARN_ONCE(ret, "failed to setup sort entries\n")) 2496 return; 2497 2498 nd = rb_first_cached(&c2c.hists.hists.entries); 2499 2500 for (; nd; nd = rb_next(nd)) { 2501 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node); 2502 struct c2c_hist_entry *c2c_he; 2503 2504 if (he->filtered) 2505 continue; 2506 2507 c2c_he = container_of(he, struct c2c_hist_entry, he); 2508 print_cacheline(c2c_he->hists, he, &hpp_list, out); 2509 } 2510 } 2511 2512 static void print_c2c_info(FILE *out, struct perf_session *session) 2513 { 2514 struct evlist *evlist = session->evlist; 2515 struct evsel *evsel; 2516 bool first = true; 2517 2518 fprintf(out, "=================================================\n"); 2519 fprintf(out, " c2c details \n"); 2520 fprintf(out, "=================================================\n"); 2521 2522 evlist__for_each_entry(evlist, evsel) { 2523 fprintf(out, "%-36s: %s\n", first ? " Events" : "", evsel__name(evsel)); 2524 first = false; 2525 } 2526 fprintf(out, " Cachelines sort on : %s\n", 2527 display_str[c2c.display]); 2528 fprintf(out, " Cacheline data grouping : %s\n", c2c.cl_sort); 2529 } 2530 2531 static void perf_c2c__hists_fprintf(FILE *out, struct perf_session *session) 2532 { 2533 setup_pager(); 2534 2535 print_c2c__display_stats(out); 2536 fprintf(out, "\n"); 2537 print_shared_cacheline_info(out); 2538 fprintf(out, "\n"); 2539 print_c2c_info(out, session); 2540 2541 if (c2c.stats_only) 2542 return; 2543 2544 fprintf(out, "\n"); 2545 fprintf(out, "=================================================\n"); 2546 fprintf(out, " Shared Data Cache Line Table \n"); 2547 fprintf(out, "=================================================\n"); 2548 fprintf(out, "#\n"); 2549 2550 hists__fprintf(&c2c.hists.hists, true, 0, 0, 0, stdout, true); 2551 2552 fprintf(out, "\n"); 2553 fprintf(out, "=================================================\n"); 2554 fprintf(out, " Shared Cache Line Distribution Pareto \n"); 2555 fprintf(out, "=================================================\n"); 2556 fprintf(out, "#\n"); 2557 2558 print_pareto(out); 2559 } 2560 2561 #ifdef HAVE_SLANG_SUPPORT 2562 static void c2c_browser__update_nr_entries(struct hist_browser *hb) 2563 { 2564 u64 nr_entries = 0; 2565 struct rb_node *nd = rb_first_cached(&hb->hists->entries); 2566 2567 while (nd) { 2568 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node); 2569 2570 if (!he->filtered) 2571 nr_entries++; 2572 2573 nd = rb_next(nd); 2574 } 2575 2576 hb->nr_non_filtered_entries = nr_entries; 2577 } 2578 2579 struct c2c_cacheline_browser { 2580 struct hist_browser hb; 2581 struct hist_entry *he; 2582 }; 2583 2584 static int 2585 perf_c2c_cacheline_browser__title(struct hist_browser *browser, 2586 char *bf, size_t size) 2587 { 2588 struct c2c_cacheline_browser *cl_browser; 2589 struct hist_entry *he; 2590 uint64_t addr = 0; 2591 2592 cl_browser = container_of(browser, struct c2c_cacheline_browser, hb); 2593 he = cl_browser->he; 2594 2595 if (he->mem_info) 2596 addr = cl_address(he->mem_info->daddr.addr); 2597 2598 scnprintf(bf, size, "Cacheline 0x%lx", addr); 2599 return 0; 2600 } 2601 2602 static struct c2c_cacheline_browser* 2603 c2c_cacheline_browser__new(struct hists *hists, struct hist_entry *he) 2604 { 2605 struct c2c_cacheline_browser *browser; 2606 2607 browser = zalloc(sizeof(*browser)); 2608 if (browser) { 2609 hist_browser__init(&browser->hb, hists); 2610 browser->hb.c2c_filter = true; 2611 browser->hb.title = perf_c2c_cacheline_browser__title; 2612 browser->he = he; 2613 } 2614 2615 return browser; 2616 } 2617 2618 static int perf_c2c__browse_cacheline(struct hist_entry *he) 2619 { 2620 struct c2c_hist_entry *c2c_he; 2621 struct c2c_hists *c2c_hists; 2622 struct c2c_cacheline_browser *cl_browser; 2623 struct hist_browser *browser; 2624 int key = -1; 2625 static const char help[] = 2626 " ENTER Toggle callchains (if present) \n" 2627 " n Toggle Node details info \n" 2628 " s Toggle full length of symbol and source line columns \n" 2629 " q Return back to cacheline list \n"; 2630 2631 if (!he) 2632 return 0; 2633 2634 /* Display compact version first. */ 2635 c2c.symbol_full = false; 2636 2637 c2c_he = container_of(he, struct c2c_hist_entry, he); 2638 c2c_hists = c2c_he->hists; 2639 2640 cl_browser = c2c_cacheline_browser__new(&c2c_hists->hists, he); 2641 if (cl_browser == NULL) 2642 return -1; 2643 2644 browser = &cl_browser->hb; 2645 2646 /* reset abort key so that it can get Ctrl-C as a key */ 2647 SLang_reset_tty(); 2648 SLang_init_tty(0, 0, 0); 2649 2650 c2c_browser__update_nr_entries(browser); 2651 2652 while (1) { 2653 key = hist_browser__run(browser, "? - help", true, 0); 2654 2655 switch (key) { 2656 case 's': 2657 c2c.symbol_full = !c2c.symbol_full; 2658 break; 2659 case 'n': 2660 c2c.node_info = (c2c.node_info + 1) % 3; 2661 setup_nodes_header(); 2662 break; 2663 case 'q': 2664 goto out; 2665 case '?': 2666 ui_browser__help_window(&browser->b, help); 2667 break; 2668 default: 2669 break; 2670 } 2671 } 2672 2673 out: 2674 free(cl_browser); 2675 return 0; 2676 } 2677 2678 static int perf_c2c_browser__title(struct hist_browser *browser, 2679 char *bf, size_t size) 2680 { 2681 scnprintf(bf, size, 2682 "Shared Data Cache Line Table " 2683 "(%lu entries, sorted on %s)", 2684 browser->nr_non_filtered_entries, 2685 display_str[c2c.display]); 2686 return 0; 2687 } 2688 2689 static struct hist_browser* 2690 perf_c2c_browser__new(struct hists *hists) 2691 { 2692 struct hist_browser *browser = hist_browser__new(hists); 2693 2694 if (browser) { 2695 browser->title = perf_c2c_browser__title; 2696 browser->c2c_filter = true; 2697 } 2698 2699 return browser; 2700 } 2701 2702 static int perf_c2c__hists_browse(struct hists *hists) 2703 { 2704 struct hist_browser *browser; 2705 int key = -1; 2706 static const char help[] = 2707 " d Display cacheline details \n" 2708 " ENTER Toggle callchains (if present) \n" 2709 " q Quit \n"; 2710 2711 browser = perf_c2c_browser__new(hists); 2712 if (browser == NULL) 2713 return -1; 2714 2715 /* reset abort key so that it can get Ctrl-C as a key */ 2716 SLang_reset_tty(); 2717 SLang_init_tty(0, 0, 0); 2718 2719 c2c_browser__update_nr_entries(browser); 2720 2721 while (1) { 2722 key = hist_browser__run(browser, "? - help", true, 0); 2723 2724 switch (key) { 2725 case 'q': 2726 goto out; 2727 case 'd': 2728 perf_c2c__browse_cacheline(browser->he_selection); 2729 break; 2730 case '?': 2731 ui_browser__help_window(&browser->b, help); 2732 break; 2733 default: 2734 break; 2735 } 2736 } 2737 2738 out: 2739 hist_browser__delete(browser); 2740 return 0; 2741 } 2742 2743 static void perf_c2c_display(struct perf_session *session) 2744 { 2745 if (use_browser == 0) 2746 perf_c2c__hists_fprintf(stdout, session); 2747 else 2748 perf_c2c__hists_browse(&c2c.hists.hists); 2749 } 2750 #else 2751 static void perf_c2c_display(struct perf_session *session) 2752 { 2753 use_browser = 0; 2754 perf_c2c__hists_fprintf(stdout, session); 2755 } 2756 #endif /* HAVE_SLANG_SUPPORT */ 2757 2758 static char *fill_line(const char *orig, int len) 2759 { 2760 int i, j, olen = strlen(orig); 2761 char *buf; 2762 2763 buf = zalloc(len + 1); 2764 if (!buf) 2765 return NULL; 2766 2767 j = len / 2 - olen / 2; 2768 2769 for (i = 0; i < j - 1; i++) 2770 buf[i] = '-'; 2771 2772 buf[i++] = ' '; 2773 2774 strcpy(buf + i, orig); 2775 2776 i += olen; 2777 2778 buf[i++] = ' '; 2779 2780 for (; i < len; i++) 2781 buf[i] = '-'; 2782 2783 return buf; 2784 } 2785 2786 static int ui_quirks(void) 2787 { 2788 const char *nodestr = "Data address"; 2789 char *buf; 2790 2791 if (!c2c.use_stdio) { 2792 dim_offset.width = 5; 2793 dim_offset.header = header_offset_tui; 2794 nodestr = "CL"; 2795 } 2796 2797 dim_percent_costly_snoop.header = percent_costly_snoop_header[c2c.display]; 2798 2799 /* Fix the zero line for dcacheline column. */ 2800 buf = fill_line("Cacheline", dim_dcacheline.width + 2801 dim_dcacheline_node.width + 2802 dim_dcacheline_count.width + 4); 2803 if (!buf) 2804 return -ENOMEM; 2805 2806 dim_dcacheline.header.line[0].text = buf; 2807 2808 /* Fix the zero line for offset column. */ 2809 buf = fill_line(nodestr, dim_offset.width + 2810 dim_offset_node.width + 2811 dim_dcacheline_count.width + 4); 2812 if (!buf) 2813 return -ENOMEM; 2814 2815 dim_offset.header.line[0].text = buf; 2816 2817 return 0; 2818 } 2819 2820 #define CALLCHAIN_DEFAULT_OPT "graph,0.5,caller,function,percent" 2821 2822 const char callchain_help[] = "Display call graph (stack chain/backtrace):\n\n" 2823 CALLCHAIN_REPORT_HELP 2824 "\n\t\t\t\tDefault: " CALLCHAIN_DEFAULT_OPT; 2825 2826 static int 2827 parse_callchain_opt(const struct option *opt, const char *arg, int unset) 2828 { 2829 struct callchain_param *callchain = opt->value; 2830 2831 callchain->enabled = !unset; 2832 /* 2833 * --no-call-graph 2834 */ 2835 if (unset) { 2836 symbol_conf.use_callchain = false; 2837 callchain->mode = CHAIN_NONE; 2838 return 0; 2839 } 2840 2841 return parse_callchain_report_opt(arg); 2842 } 2843 2844 static int setup_callchain(struct evlist *evlist) 2845 { 2846 u64 sample_type = evlist__combined_sample_type(evlist); 2847 enum perf_call_graph_mode mode = CALLCHAIN_NONE; 2848 2849 if ((sample_type & PERF_SAMPLE_REGS_USER) && 2850 (sample_type & PERF_SAMPLE_STACK_USER)) { 2851 mode = CALLCHAIN_DWARF; 2852 dwarf_callchain_users = true; 2853 } else if (sample_type & PERF_SAMPLE_BRANCH_STACK) 2854 mode = CALLCHAIN_LBR; 2855 else if (sample_type & PERF_SAMPLE_CALLCHAIN) 2856 mode = CALLCHAIN_FP; 2857 2858 if (!callchain_param.enabled && 2859 callchain_param.mode != CHAIN_NONE && 2860 mode != CALLCHAIN_NONE) { 2861 symbol_conf.use_callchain = true; 2862 if (callchain_register_param(&callchain_param) < 0) { 2863 ui__error("Can't register callchain params.\n"); 2864 return -EINVAL; 2865 } 2866 } 2867 2868 if (c2c.stitch_lbr && (mode != CALLCHAIN_LBR)) { 2869 ui__warning("Can't find LBR callchain. Switch off --stitch-lbr.\n" 2870 "Please apply --call-graph lbr when recording.\n"); 2871 c2c.stitch_lbr = false; 2872 } 2873 2874 callchain_param.record_mode = mode; 2875 callchain_param.min_percent = 0; 2876 return 0; 2877 } 2878 2879 static int setup_display(const char *str) 2880 { 2881 const char *display = str; 2882 2883 if (!strcmp(display, "tot")) 2884 c2c.display = DISPLAY_TOT_HITM; 2885 else if (!strcmp(display, "rmt")) 2886 c2c.display = DISPLAY_RMT_HITM; 2887 else if (!strcmp(display, "lcl")) 2888 c2c.display = DISPLAY_LCL_HITM; 2889 else if (!strcmp(display, "peer")) 2890 c2c.display = DISPLAY_SNP_PEER; 2891 else { 2892 pr_err("failed: unknown display type: %s\n", str); 2893 return -1; 2894 } 2895 2896 return 0; 2897 } 2898 2899 #define for_each_token(__tok, __buf, __sep, __tmp) \ 2900 for (__tok = strtok_r(__buf, __sep, &__tmp); __tok; \ 2901 __tok = strtok_r(NULL, __sep, &__tmp)) 2902 2903 static int build_cl_output(char *cl_sort, bool no_source) 2904 { 2905 char *tok, *tmp, *buf = strdup(cl_sort); 2906 bool add_pid = false; 2907 bool add_tid = false; 2908 bool add_iaddr = false; 2909 bool add_sym = false; 2910 bool add_dso = false; 2911 bool add_src = false; 2912 int ret = 0; 2913 2914 if (!buf) 2915 return -ENOMEM; 2916 2917 for_each_token(tok, buf, ",", tmp) { 2918 if (!strcmp(tok, "tid")) { 2919 add_tid = true; 2920 } else if (!strcmp(tok, "pid")) { 2921 add_pid = true; 2922 } else if (!strcmp(tok, "iaddr")) { 2923 add_iaddr = true; 2924 add_sym = true; 2925 add_dso = true; 2926 add_src = no_source ? false : true; 2927 } else if (!strcmp(tok, "dso")) { 2928 add_dso = true; 2929 } else if (strcmp(tok, "offset")) { 2930 pr_err("unrecognized sort token: %s\n", tok); 2931 ret = -EINVAL; 2932 goto err; 2933 } 2934 } 2935 2936 if (asprintf(&c2c.cl_output, 2937 "%s%s%s%s%s%s%s%s%s%s%s%s", 2938 c2c.use_stdio ? "cl_num_empty," : "", 2939 c2c.display == DISPLAY_SNP_PEER ? "percent_rmt_peer," 2940 "percent_lcl_peer," : 2941 "percent_rmt_hitm," 2942 "percent_lcl_hitm,", 2943 "percent_stores_l1hit," 2944 "percent_stores_l1miss," 2945 "percent_stores_na," 2946 "offset,offset_node,dcacheline_count,", 2947 add_pid ? "pid," : "", 2948 add_tid ? "tid," : "", 2949 add_iaddr ? "iaddr," : "", 2950 c2c.display == DISPLAY_SNP_PEER ? "mean_rmt_peer," 2951 "mean_lcl_peer," : 2952 "mean_rmt," 2953 "mean_lcl,", 2954 "mean_load," 2955 "tot_recs," 2956 "cpucnt,", 2957 add_sym ? "symbol," : "", 2958 add_dso ? "dso," : "", 2959 add_src ? "cl_srcline," : "", 2960 "node") < 0) { 2961 ret = -ENOMEM; 2962 goto err; 2963 } 2964 2965 c2c.show_src = add_src; 2966 err: 2967 free(buf); 2968 return ret; 2969 } 2970 2971 static int setup_coalesce(const char *coalesce, bool no_source) 2972 { 2973 const char *c = coalesce ?: coalesce_default; 2974 const char *sort_str = NULL; 2975 2976 if (asprintf(&c2c.cl_sort, "offset,%s", c) < 0) 2977 return -ENOMEM; 2978 2979 if (build_cl_output(c2c.cl_sort, no_source)) 2980 return -1; 2981 2982 if (c2c.display == DISPLAY_TOT_HITM) 2983 sort_str = "tot_hitm"; 2984 else if (c2c.display == DISPLAY_RMT_HITM) 2985 sort_str = "rmt_hitm,lcl_hitm"; 2986 else if (c2c.display == DISPLAY_LCL_HITM) 2987 sort_str = "lcl_hitm,rmt_hitm"; 2988 else if (c2c.display == DISPLAY_SNP_PEER) 2989 sort_str = "tot_peer"; 2990 2991 if (asprintf(&c2c.cl_resort, "offset,%s", sort_str) < 0) 2992 return -ENOMEM; 2993 2994 pr_debug("coalesce sort fields: %s\n", c2c.cl_sort); 2995 pr_debug("coalesce resort fields: %s\n", c2c.cl_resort); 2996 pr_debug("coalesce output fields: %s\n", c2c.cl_output); 2997 return 0; 2998 } 2999 3000 static int perf_c2c__report(int argc, const char **argv) 3001 { 3002 struct itrace_synth_opts itrace_synth_opts = { 3003 .set = true, 3004 .mem = true, /* Only enable memory event */ 3005 .default_no_sample = true, 3006 }; 3007 3008 struct perf_session *session; 3009 struct ui_progress prog; 3010 struct perf_data data = { 3011 .mode = PERF_DATA_MODE_READ, 3012 }; 3013 char callchain_default_opt[] = CALLCHAIN_DEFAULT_OPT; 3014 const char *display = NULL; 3015 const char *coalesce = NULL; 3016 bool no_source = false; 3017 const struct option options[] = { 3018 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 3019 "file", "vmlinux pathname"), 3020 OPT_STRING('i', "input", &input_name, "file", 3021 "the input file to process"), 3022 OPT_INCR('N', "node-info", &c2c.node_info, 3023 "show extra node info in report (repeat for more info)"), 3024 OPT_BOOLEAN(0, "stdio", &c2c.use_stdio, "Use the stdio interface"), 3025 OPT_BOOLEAN(0, "stats", &c2c.stats_only, 3026 "Display only statistic tables (implies --stdio)"), 3027 OPT_BOOLEAN(0, "full-symbols", &c2c.symbol_full, 3028 "Display full length of symbols"), 3029 OPT_BOOLEAN(0, "no-source", &no_source, 3030 "Do not display Source Line column"), 3031 OPT_BOOLEAN(0, "show-all", &c2c.show_all, 3032 "Show all captured HITM lines."), 3033 OPT_CALLBACK_DEFAULT('g', "call-graph", &callchain_param, 3034 "print_type,threshold[,print_limit],order,sort_key[,branch],value", 3035 callchain_help, &parse_callchain_opt, 3036 callchain_default_opt), 3037 OPT_STRING('d', "display", &display, "Switch HITM output type", "tot,lcl,rmt,peer"), 3038 OPT_STRING('c', "coalesce", &coalesce, "coalesce fields", 3039 "coalesce fields: pid,tid,iaddr,dso"), 3040 OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"), 3041 OPT_BOOLEAN(0, "stitch-lbr", &c2c.stitch_lbr, 3042 "Enable LBR callgraph stitching approach"), 3043 OPT_PARENT(c2c_options), 3044 OPT_END() 3045 }; 3046 int err = 0; 3047 const char *output_str, *sort_str = NULL; 3048 3049 argc = parse_options(argc, argv, options, report_c2c_usage, 3050 PARSE_OPT_STOP_AT_NON_OPTION); 3051 if (argc) 3052 usage_with_options(report_c2c_usage, options); 3053 3054 #ifndef HAVE_SLANG_SUPPORT 3055 c2c.use_stdio = true; 3056 #endif 3057 3058 if (c2c.stats_only) 3059 c2c.use_stdio = true; 3060 3061 err = symbol__validate_sym_arguments(); 3062 if (err) 3063 goto out; 3064 3065 if (!input_name || !strlen(input_name)) 3066 input_name = "perf.data"; 3067 3068 data.path = input_name; 3069 data.force = symbol_conf.force; 3070 3071 session = perf_session__new(&data, &c2c.tool); 3072 if (IS_ERR(session)) { 3073 err = PTR_ERR(session); 3074 pr_debug("Error creating perf session\n"); 3075 goto out; 3076 } 3077 3078 /* 3079 * Use the 'tot' as default display type if user doesn't specify it; 3080 * since Arm64 platform doesn't support HITMs flag, use 'peer' as the 3081 * default display type. 3082 */ 3083 if (!display) { 3084 if (!strcmp(perf_env__arch(&session->header.env), "arm64")) 3085 display = "peer"; 3086 else 3087 display = "tot"; 3088 } 3089 3090 err = setup_display(display); 3091 if (err) 3092 goto out_session; 3093 3094 err = setup_coalesce(coalesce, no_source); 3095 if (err) { 3096 pr_debug("Failed to initialize hists\n"); 3097 goto out_session; 3098 } 3099 3100 err = c2c_hists__init(&c2c.hists, "dcacheline", 2); 3101 if (err) { 3102 pr_debug("Failed to initialize hists\n"); 3103 goto out_session; 3104 } 3105 3106 session->itrace_synth_opts = &itrace_synth_opts; 3107 3108 err = setup_nodes(session); 3109 if (err) { 3110 pr_err("Failed setup nodes\n"); 3111 goto out_session; 3112 } 3113 3114 err = mem2node__init(&c2c.mem2node, &session->header.env); 3115 if (err) 3116 goto out_session; 3117 3118 err = setup_callchain(session->evlist); 3119 if (err) 3120 goto out_mem2node; 3121 3122 if (symbol__init(&session->header.env) < 0) 3123 goto out_mem2node; 3124 3125 /* No pipe support at the moment. */ 3126 if (perf_data__is_pipe(session->data)) { 3127 pr_debug("No pipe support at the moment.\n"); 3128 goto out_mem2node; 3129 } 3130 3131 if (c2c.use_stdio) 3132 use_browser = 0; 3133 else 3134 use_browser = 1; 3135 3136 setup_browser(false); 3137 3138 err = perf_session__process_events(session); 3139 if (err) { 3140 pr_err("failed to process sample\n"); 3141 goto out_mem2node; 3142 } 3143 3144 if (c2c.display != DISPLAY_SNP_PEER) 3145 output_str = "cl_idx," 3146 "dcacheline," 3147 "dcacheline_node," 3148 "dcacheline_count," 3149 "percent_costly_snoop," 3150 "tot_hitm,lcl_hitm,rmt_hitm," 3151 "tot_recs," 3152 "tot_loads," 3153 "tot_stores," 3154 "stores_l1hit,stores_l1miss,stores_na," 3155 "ld_fbhit,ld_l1hit,ld_l2hit," 3156 "ld_lclhit,lcl_hitm," 3157 "ld_rmthit,rmt_hitm," 3158 "dram_lcl,dram_rmt"; 3159 else 3160 output_str = "cl_idx," 3161 "dcacheline," 3162 "dcacheline_node," 3163 "dcacheline_count," 3164 "percent_costly_snoop," 3165 "tot_peer,lcl_peer,rmt_peer," 3166 "tot_recs," 3167 "tot_loads," 3168 "tot_stores," 3169 "stores_l1hit,stores_l1miss,stores_na," 3170 "ld_fbhit,ld_l1hit,ld_l2hit," 3171 "ld_lclhit,lcl_hitm," 3172 "ld_rmthit,rmt_hitm," 3173 "dram_lcl,dram_rmt"; 3174 3175 if (c2c.display == DISPLAY_TOT_HITM) 3176 sort_str = "tot_hitm"; 3177 else if (c2c.display == DISPLAY_RMT_HITM) 3178 sort_str = "rmt_hitm"; 3179 else if (c2c.display == DISPLAY_LCL_HITM) 3180 sort_str = "lcl_hitm"; 3181 else if (c2c.display == DISPLAY_SNP_PEER) 3182 sort_str = "tot_peer"; 3183 3184 c2c_hists__reinit(&c2c.hists, output_str, sort_str); 3185 3186 ui_progress__init(&prog, c2c.hists.hists.nr_entries, "Sorting..."); 3187 3188 hists__collapse_resort(&c2c.hists.hists, NULL); 3189 hists__output_resort_cb(&c2c.hists.hists, &prog, resort_shared_cl_cb); 3190 hists__iterate_cb(&c2c.hists.hists, resort_cl_cb); 3191 3192 ui_progress__finish(); 3193 3194 if (ui_quirks()) { 3195 pr_err("failed to setup UI\n"); 3196 goto out_mem2node; 3197 } 3198 3199 perf_c2c_display(session); 3200 3201 out_mem2node: 3202 mem2node__exit(&c2c.mem2node); 3203 out_session: 3204 perf_session__delete(session); 3205 out: 3206 return err; 3207 } 3208 3209 static int parse_record_events(const struct option *opt, 3210 const char *str, int unset __maybe_unused) 3211 { 3212 bool *event_set = (bool *) opt->value; 3213 3214 if (!strcmp(str, "list")) { 3215 perf_mem_events__list(); 3216 exit(0); 3217 } 3218 if (perf_mem_events__parse(str)) 3219 exit(-1); 3220 3221 *event_set = true; 3222 return 0; 3223 } 3224 3225 3226 static const char * const __usage_record[] = { 3227 "perf c2c record [<options>] [<command>]", 3228 "perf c2c record [<options>] -- <command> [<options>]", 3229 NULL 3230 }; 3231 3232 static const char * const *record_mem_usage = __usage_record; 3233 3234 static int perf_c2c__record(int argc, const char **argv) 3235 { 3236 int rec_argc, i = 0, j, rec_tmp_nr = 0; 3237 const char **rec_argv; 3238 char **rec_tmp; 3239 int ret; 3240 bool all_user = false, all_kernel = false; 3241 bool event_set = false; 3242 struct perf_mem_event *e; 3243 struct option options[] = { 3244 OPT_CALLBACK('e', "event", &event_set, "event", 3245 "event selector. Use 'perf c2c record -e list' to list available events", 3246 parse_record_events), 3247 OPT_BOOLEAN('u', "all-user", &all_user, "collect only user level data"), 3248 OPT_BOOLEAN('k', "all-kernel", &all_kernel, "collect only kernel level data"), 3249 OPT_UINTEGER('l', "ldlat", &perf_mem_events__loads_ldlat, "setup mem-loads latency"), 3250 OPT_PARENT(c2c_options), 3251 OPT_END() 3252 }; 3253 3254 if (perf_mem_events__init()) { 3255 pr_err("failed: memory events not supported\n"); 3256 return -1; 3257 } 3258 3259 argc = parse_options(argc, argv, options, record_mem_usage, 3260 PARSE_OPT_KEEP_UNKNOWN); 3261 3262 if (!perf_pmu__has_hybrid()) 3263 rec_argc = argc + 11; /* max number of arguments */ 3264 else 3265 rec_argc = argc + 11 * perf_pmu__hybrid_pmu_num(); 3266 3267 rec_argv = calloc(rec_argc + 1, sizeof(char *)); 3268 if (!rec_argv) 3269 return -1; 3270 3271 rec_tmp = calloc(rec_argc + 1, sizeof(char *)); 3272 if (!rec_tmp) { 3273 free(rec_argv); 3274 return -1; 3275 } 3276 3277 rec_argv[i++] = "record"; 3278 3279 if (!event_set) { 3280 e = perf_mem_events__ptr(PERF_MEM_EVENTS__LOAD_STORE); 3281 /* 3282 * The load and store operations are required, use the event 3283 * PERF_MEM_EVENTS__LOAD_STORE if it is supported. 3284 */ 3285 if (e->tag) { 3286 e->record = true; 3287 } else { 3288 e = perf_mem_events__ptr(PERF_MEM_EVENTS__LOAD); 3289 e->record = true; 3290 3291 e = perf_mem_events__ptr(PERF_MEM_EVENTS__STORE); 3292 e->record = true; 3293 } 3294 } 3295 3296 e = perf_mem_events__ptr(PERF_MEM_EVENTS__LOAD); 3297 if (e->record) 3298 rec_argv[i++] = "-W"; 3299 3300 rec_argv[i++] = "-d"; 3301 rec_argv[i++] = "--phys-data"; 3302 rec_argv[i++] = "--sample-cpu"; 3303 3304 ret = perf_mem_events__record_args(rec_argv, &i, rec_tmp, &rec_tmp_nr); 3305 if (ret) 3306 goto out; 3307 3308 if (all_user) 3309 rec_argv[i++] = "--all-user"; 3310 3311 if (all_kernel) 3312 rec_argv[i++] = "--all-kernel"; 3313 3314 for (j = 0; j < argc; j++, i++) 3315 rec_argv[i] = argv[j]; 3316 3317 if (verbose > 0) { 3318 pr_debug("calling: "); 3319 3320 j = 0; 3321 3322 while (rec_argv[j]) { 3323 pr_debug("%s ", rec_argv[j]); 3324 j++; 3325 } 3326 pr_debug("\n"); 3327 } 3328 3329 ret = cmd_record(i, rec_argv); 3330 out: 3331 for (i = 0; i < rec_tmp_nr; i++) 3332 free(rec_tmp[i]); 3333 3334 free(rec_tmp); 3335 free(rec_argv); 3336 return ret; 3337 } 3338 3339 int cmd_c2c(int argc, const char **argv) 3340 { 3341 argc = parse_options(argc, argv, c2c_options, c2c_usage, 3342 PARSE_OPT_STOP_AT_NON_OPTION); 3343 3344 if (!argc) 3345 usage_with_options(c2c_usage, c2c_options); 3346 3347 if (strlen(argv[0]) > 2 && strstarts("record", argv[0])) { 3348 return perf_c2c__record(argc, argv); 3349 } else if (strlen(argv[0]) > 2 && strstarts("report", argv[0])) { 3350 return perf_c2c__report(argc, argv); 3351 } else { 3352 usage_with_options(c2c_usage, c2c_options); 3353 } 3354 3355 return 0; 3356 } 3357