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