1 // SPDX-License-Identifier: GPL-2.0
3 * This is rewrite of original c2c tool introduced in here:
4 * http://lwn.net/Articles/588866/
6 * The original tool was changed to fit in current perf state.
9 * Don Zickus <dzickus@redhat.com>
10 * Dick Fowles <fowles@inreach.com>
11 * Joe Mario <jmario@redhat.com>
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>
21 #include <sys/param.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"
33 #include "cacheline.h"
38 #include "ui/browsers/hists.h"
43 #include "ui/progress.h"
48 struct perf_hpp_list list
;
49 struct c2c_stats stats
;
52 struct compute_stats
{
53 struct stats lcl_hitm
;
54 struct stats rmt_hitm
;
58 struct c2c_hist_entry
{
59 struct c2c_hists
*hists
;
60 struct c2c_stats stats
;
61 unsigned long *cpuset
;
62 unsigned long *nodeset
;
63 struct c2c_stats
*node_stats
;
64 unsigned int cacheline_idx
;
66 struct compute_stats cstats
;
69 unsigned long paddr_cnt
;
75 * because of its callchain dynamic entry
80 static char const *coalesce_default
= "iaddr";
83 struct perf_tool tool
;
84 struct c2c_hists hists
;
85 struct mem2node mem2node
;
87 unsigned long **nodes
;
99 /* HITM shared clines stats */
100 struct c2c_stats hitm_stats
;
105 const char *coalesce
;
118 static const char *display_str
[DISPLAY_MAX
] = {
119 [DISPLAY_LCL
] = "Local",
120 [DISPLAY_RMT
] = "Remote",
121 [DISPLAY_TOT
] = "Total",
124 static const struct option c2c_options
[] = {
125 OPT_INCR('v', "verbose", &verbose
, "be more verbose (show counter open errors, etc)"),
129 static struct perf_c2c c2c
;
131 static void *c2c_he_zalloc(size_t size
)
133 struct c2c_hist_entry
*c2c_he
;
135 c2c_he
= zalloc(size
+ sizeof(*c2c_he
));
139 c2c_he
->cpuset
= bitmap_alloc(c2c
.cpus_cnt
);
143 c2c_he
->nodeset
= bitmap_alloc(c2c
.nodes_cnt
);
144 if (!c2c_he
->nodeset
)
147 c2c_he
->node_stats
= zalloc(c2c
.nodes_cnt
* sizeof(*c2c_he
->node_stats
));
148 if (!c2c_he
->node_stats
)
151 init_stats(&c2c_he
->cstats
.lcl_hitm
);
152 init_stats(&c2c_he
->cstats
.rmt_hitm
);
153 init_stats(&c2c_he
->cstats
.load
);
158 static void c2c_he_free(void *he
)
160 struct c2c_hist_entry
*c2c_he
;
162 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
164 hists__delete_entries(&c2c_he
->hists
->hists
);
168 free(c2c_he
->cpuset
);
169 free(c2c_he
->nodeset
);
170 free(c2c_he
->nodestr
);
171 free(c2c_he
->node_stats
);
175 static struct hist_entry_ops c2c_entry_ops
= {
176 .new = c2c_he_zalloc
,
180 static int c2c_hists__init(struct c2c_hists
*hists
,
182 int nr_header_lines
);
184 static struct c2c_hists
*
185 he__get_c2c_hists(struct hist_entry
*he
,
189 struct c2c_hist_entry
*c2c_he
;
190 struct c2c_hists
*hists
;
193 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
195 return c2c_he
->hists
;
197 hists
= c2c_he
->hists
= zalloc(sizeof(*hists
));
201 ret
= c2c_hists__init(hists
, sort
, nr_header_lines
);
210 static void c2c_he__set_cpu(struct c2c_hist_entry
*c2c_he
,
211 struct perf_sample
*sample
)
213 if (WARN_ONCE(sample
->cpu
== (unsigned int) -1,
214 "WARNING: no sample cpu value"))
217 set_bit(sample
->cpu
, c2c_he
->cpuset
);
220 static void c2c_he__set_node(struct c2c_hist_entry
*c2c_he
,
221 struct perf_sample
*sample
)
225 if (!sample
->phys_addr
) {
226 c2c_he
->paddr_zero
= true;
230 node
= mem2node__node(&c2c
.mem2node
, sample
->phys_addr
);
231 if (WARN_ONCE(node
< 0, "WARNING: failed to find node\n"))
234 set_bit(node
, c2c_he
->nodeset
);
236 if (c2c_he
->paddr
!= sample
->phys_addr
) {
238 c2c_he
->paddr
= sample
->phys_addr
;
242 static void compute_stats(struct c2c_hist_entry
*c2c_he
,
243 struct c2c_stats
*stats
,
246 struct compute_stats
*cstats
= &c2c_he
->cstats
;
249 update_stats(&cstats
->rmt_hitm
, weight
);
250 else if (stats
->lcl_hitm
)
251 update_stats(&cstats
->lcl_hitm
, weight
);
252 else if (stats
->load
)
253 update_stats(&cstats
->load
, weight
);
256 static int process_sample_event(struct perf_tool
*tool __maybe_unused
,
257 union perf_event
*event
,
258 struct perf_sample
*sample
,
260 struct machine
*machine
)
262 struct c2c_hists
*c2c_hists
= &c2c
.hists
;
263 struct c2c_hist_entry
*c2c_he
;
264 struct c2c_stats stats
= { .nr_entries
= 0, };
265 struct hist_entry
*he
;
266 struct addr_location al
;
267 struct mem_info
*mi
, *mi_dup
;
270 if (machine__resolve(machine
, &al
, sample
) < 0) {
271 pr_debug("problem processing %d event, skipping it.\n",
276 ret
= sample__resolve_callchain(sample
, &callchain_cursor
, NULL
,
277 evsel
, &al
, sysctl_perf_event_max_stack
);
281 mi
= sample__resolve_mem(sample
, &al
);
286 * The mi object is released in hists__add_entry_ops,
287 * if it gets sorted out into existing data, so we need
288 * to take the copy now.
290 mi_dup
= mem_info__get(mi
);
292 c2c_decode_stats(&stats
, mi
);
294 he
= hists__add_entry_ops(&c2c_hists
->hists
, &c2c_entry_ops
,
300 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
301 c2c_add_stats(&c2c_he
->stats
, &stats
);
302 c2c_add_stats(&c2c_hists
->stats
, &stats
);
304 c2c_he__set_cpu(c2c_he
, sample
);
305 c2c_he__set_node(c2c_he
, sample
);
307 hists__inc_nr_samples(&c2c_hists
->hists
, he
->filtered
);
308 ret
= hist_entry__append_callchain(he
, sample
);
312 * There's already been warning about missing
313 * sample's cpu value. Let's account all to
314 * node 0 in this case, without any further
317 * Doing node stats only for single callchain data.
319 int cpu
= sample
->cpu
== (unsigned int) -1 ? 0 : sample
->cpu
;
320 int node
= c2c
.cpu2node
[cpu
];
324 c2c_hists
= he__get_c2c_hists(he
, c2c
.cl_sort
, 2);
328 he
= hists__add_entry_ops(&c2c_hists
->hists
, &c2c_entry_ops
,
334 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
335 c2c_add_stats(&c2c_he
->stats
, &stats
);
336 c2c_add_stats(&c2c_hists
->stats
, &stats
);
337 c2c_add_stats(&c2c_he
->node_stats
[node
], &stats
);
339 compute_stats(c2c_he
, &stats
, sample
->weight
);
341 c2c_he__set_cpu(c2c_he
, sample
);
342 c2c_he__set_node(c2c_he
, sample
);
344 hists__inc_nr_samples(&c2c_hists
->hists
, he
->filtered
);
345 ret
= hist_entry__append_callchain(he
, sample
);
349 addr_location__put(&al
);
353 mem_info__put(mi_dup
);
359 static struct perf_c2c c2c
= {
361 .sample
= process_sample_event
,
362 .mmap
= perf_event__process_mmap
,
363 .mmap2
= perf_event__process_mmap2
,
364 .comm
= perf_event__process_comm
,
365 .exit
= perf_event__process_exit
,
366 .fork
= perf_event__process_fork
,
367 .lost
= perf_event__process_lost
,
368 .ordered_events
= true,
369 .ordering_requires_timestamps
= true,
373 static const char * const c2c_usage
[] = {
374 "perf c2c {record|report}",
378 static const char * const __usage_report
[] = {
383 static const char * const *report_c2c_usage
= __usage_report
;
385 #define C2C_HEADER_MAX 2
391 } line
[C2C_HEADER_MAX
];
394 struct c2c_dimension
{
395 struct c2c_header header
;
398 struct sort_entry
*se
;
400 int64_t (*cmp
)(struct perf_hpp_fmt
*fmt
,
401 struct hist_entry
*, struct hist_entry
*);
402 int (*entry
)(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
403 struct hist_entry
*he
);
404 int (*color
)(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
405 struct hist_entry
*he
);
409 struct perf_hpp_fmt fmt
;
410 struct c2c_dimension
*dim
;
413 #define SYMBOL_WIDTH 30
415 static struct c2c_dimension dim_symbol
;
416 static struct c2c_dimension dim_srcline
;
418 static int symbol_width(struct hists
*hists
, struct sort_entry
*se
)
420 int width
= hists__col_len(hists
, se
->se_width_idx
);
422 if (!c2c
.symbol_full
)
423 width
= MIN(width
, SYMBOL_WIDTH
);
428 static int c2c_width(struct perf_hpp_fmt
*fmt
,
429 struct perf_hpp
*hpp __maybe_unused
,
432 struct c2c_fmt
*c2c_fmt
;
433 struct c2c_dimension
*dim
;
435 c2c_fmt
= container_of(fmt
, struct c2c_fmt
, fmt
);
438 if (dim
== &dim_symbol
|| dim
== &dim_srcline
)
439 return symbol_width(hists
, dim
->se
);
441 return dim
->se
? hists__col_len(hists
, dim
->se
->se_width_idx
) :
445 static int c2c_header(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
446 struct hists
*hists
, int line
, int *span
)
448 struct perf_hpp_list
*hpp_list
= hists
->hpp_list
;
449 struct c2c_fmt
*c2c_fmt
;
450 struct c2c_dimension
*dim
;
451 const char *text
= NULL
;
452 int width
= c2c_width(fmt
, hpp
, hists
);
454 c2c_fmt
= container_of(fmt
, struct c2c_fmt
, fmt
);
458 text
= dim
->header
.line
[line
].text
;
459 /* Use the last line from sort_entry if not defined. */
460 if (!text
&& (line
== hpp_list
->nr_header_lines
- 1))
461 text
= dim
->se
->se_header
;
463 text
= dim
->header
.line
[line
].text
;
469 *span
= dim
->header
.line
[line
].span
;
476 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, text
);
479 #define HEX_STR(__s, __v) \
481 scnprintf(__s, sizeof(__s), "0x%" PRIx64, __v); \
486 dcacheline_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
487 struct hist_entry
*left
, struct hist_entry
*right
)
489 return sort__dcacheline_cmp(left
, right
);
492 static int dcacheline_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
493 struct hist_entry
*he
)
496 int width
= c2c_width(fmt
, hpp
, he
->hists
);
500 addr
= cl_address(he
->mem_info
->daddr
.addr
);
502 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, HEX_STR(buf
, addr
));
506 dcacheline_node_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
507 struct hist_entry
*he
)
509 struct c2c_hist_entry
*c2c_he
;
510 int width
= c2c_width(fmt
, hpp
, he
->hists
);
512 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
513 if (WARN_ON_ONCE(!c2c_he
->nodestr
))
516 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, c2c_he
->nodestr
);
520 dcacheline_node_count(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
521 struct hist_entry
*he
)
523 struct c2c_hist_entry
*c2c_he
;
524 int width
= c2c_width(fmt
, hpp
, he
->hists
);
526 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
527 return scnprintf(hpp
->buf
, hpp
->size
, "%*lu", width
, c2c_he
->paddr_cnt
);
530 static int offset_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
531 struct hist_entry
*he
)
534 int width
= c2c_width(fmt
, hpp
, he
->hists
);
538 addr
= cl_offset(he
->mem_info
->daddr
.al_addr
);
540 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, HEX_STR(buf
, addr
));
544 offset_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
545 struct hist_entry
*left
, struct hist_entry
*right
)
547 uint64_t l
= 0, r
= 0;
550 l
= cl_offset(left
->mem_info
->daddr
.addr
);
552 r
= cl_offset(right
->mem_info
->daddr
.addr
);
554 return (int64_t)(r
- l
);
558 iaddr_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
559 struct hist_entry
*he
)
562 int width
= c2c_width(fmt
, hpp
, he
->hists
);
566 addr
= he
->mem_info
->iaddr
.addr
;
568 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, HEX_STR(buf
, addr
));
572 iaddr_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
573 struct hist_entry
*left
, struct hist_entry
*right
)
575 return sort__iaddr_cmp(left
, right
);
579 tot_hitm_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
580 struct hist_entry
*he
)
582 struct c2c_hist_entry
*c2c_he
;
583 int width
= c2c_width(fmt
, hpp
, he
->hists
);
584 unsigned int tot_hitm
;
586 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
587 tot_hitm
= c2c_he
->stats
.lcl_hitm
+ c2c_he
->stats
.rmt_hitm
;
589 return scnprintf(hpp
->buf
, hpp
->size
, "%*u", width
, tot_hitm
);
593 tot_hitm_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
594 struct hist_entry
*left
, struct hist_entry
*right
)
596 struct c2c_hist_entry
*c2c_left
;
597 struct c2c_hist_entry
*c2c_right
;
598 unsigned int tot_hitm_left
;
599 unsigned int tot_hitm_right
;
601 c2c_left
= container_of(left
, struct c2c_hist_entry
, he
);
602 c2c_right
= container_of(right
, struct c2c_hist_entry
, he
);
604 tot_hitm_left
= c2c_left
->stats
.lcl_hitm
+ c2c_left
->stats
.rmt_hitm
;
605 tot_hitm_right
= c2c_right
->stats
.lcl_hitm
+ c2c_right
->stats
.rmt_hitm
;
607 return tot_hitm_left
- tot_hitm_right
;
610 #define STAT_FN_ENTRY(__f) \
612 __f ## _entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, \
613 struct hist_entry *he) \
615 struct c2c_hist_entry *c2c_he; \
616 int width = c2c_width(fmt, hpp, he->hists); \
618 c2c_he = container_of(he, struct c2c_hist_entry, he); \
619 return scnprintf(hpp->buf, hpp->size, "%*u", width, \
620 c2c_he->stats.__f); \
623 #define STAT_FN_CMP(__f) \
625 __f ## _cmp(struct perf_hpp_fmt *fmt __maybe_unused, \
626 struct hist_entry *left, struct hist_entry *right) \
628 struct c2c_hist_entry *c2c_left, *c2c_right; \
630 c2c_left = container_of(left, struct c2c_hist_entry, he); \
631 c2c_right = container_of(right, struct c2c_hist_entry, he); \
632 return c2c_left->stats.__f - c2c_right->stats.__f; \
635 #define STAT_FN(__f) \
650 static uint64_t llc_miss(struct c2c_stats
*stats
)
654 llcmiss
= stats
->lcl_dram
+
663 ld_llcmiss_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
664 struct hist_entry
*he
)
666 struct c2c_hist_entry
*c2c_he
;
667 int width
= c2c_width(fmt
, hpp
, he
->hists
);
669 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
671 return scnprintf(hpp
->buf
, hpp
->size
, "%*lu", width
,
672 llc_miss(&c2c_he
->stats
));
676 ld_llcmiss_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
677 struct hist_entry
*left
, struct hist_entry
*right
)
679 struct c2c_hist_entry
*c2c_left
;
680 struct c2c_hist_entry
*c2c_right
;
682 c2c_left
= container_of(left
, struct c2c_hist_entry
, he
);
683 c2c_right
= container_of(right
, struct c2c_hist_entry
, he
);
685 return llc_miss(&c2c_left
->stats
) - llc_miss(&c2c_right
->stats
);
688 static uint64_t total_records(struct c2c_stats
*stats
)
690 uint64_t lclmiss
, ldcnt
, total
;
692 lclmiss
= stats
->lcl_dram
+
712 tot_recs_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
713 struct hist_entry
*he
)
715 struct c2c_hist_entry
*c2c_he
;
716 int width
= c2c_width(fmt
, hpp
, he
->hists
);
719 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
720 tot_recs
= total_records(&c2c_he
->stats
);
722 return scnprintf(hpp
->buf
, hpp
->size
, "%*" PRIu64
, width
, tot_recs
);
726 tot_recs_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
727 struct hist_entry
*left
, struct hist_entry
*right
)
729 struct c2c_hist_entry
*c2c_left
;
730 struct c2c_hist_entry
*c2c_right
;
731 uint64_t tot_recs_left
;
732 uint64_t tot_recs_right
;
734 c2c_left
= container_of(left
, struct c2c_hist_entry
, he
);
735 c2c_right
= container_of(right
, struct c2c_hist_entry
, he
);
737 tot_recs_left
= total_records(&c2c_left
->stats
);
738 tot_recs_right
= total_records(&c2c_right
->stats
);
740 return tot_recs_left
- tot_recs_right
;
743 static uint64_t total_loads(struct c2c_stats
*stats
)
745 uint64_t lclmiss
, ldcnt
;
747 lclmiss
= stats
->lcl_dram
+
763 tot_loads_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
764 struct hist_entry
*he
)
766 struct c2c_hist_entry
*c2c_he
;
767 int width
= c2c_width(fmt
, hpp
, he
->hists
);
770 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
771 tot_recs
= total_loads(&c2c_he
->stats
);
773 return scnprintf(hpp
->buf
, hpp
->size
, "%*" PRIu64
, width
, tot_recs
);
777 tot_loads_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
778 struct hist_entry
*left
, struct hist_entry
*right
)
780 struct c2c_hist_entry
*c2c_left
;
781 struct c2c_hist_entry
*c2c_right
;
782 uint64_t tot_recs_left
;
783 uint64_t tot_recs_right
;
785 c2c_left
= container_of(left
, struct c2c_hist_entry
, he
);
786 c2c_right
= container_of(right
, struct c2c_hist_entry
, he
);
788 tot_recs_left
= total_loads(&c2c_left
->stats
);
789 tot_recs_right
= total_loads(&c2c_right
->stats
);
791 return tot_recs_left
- tot_recs_right
;
794 typedef double (get_percent_cb
)(struct c2c_hist_entry
*);
797 percent_color(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
798 struct hist_entry
*he
, get_percent_cb get_percent
)
800 struct c2c_hist_entry
*c2c_he
;
801 int width
= c2c_width(fmt
, hpp
, he
->hists
);
804 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
805 per
= get_percent(c2c_he
);
807 #ifdef HAVE_SLANG_SUPPORT
809 return __hpp__slsmg_color_printf(hpp
, "%*.2f%%", width
- 1, per
);
811 return hpp_color_scnprintf(hpp
, "%*.2f%%", width
- 1, per
);
814 static double percent_hitm(struct c2c_hist_entry
*c2c_he
)
816 struct c2c_hists
*hists
;
817 struct c2c_stats
*stats
;
818 struct c2c_stats
*total
;
822 hists
= container_of(c2c_he
->he
.hists
, struct c2c_hists
, hists
);
823 stats
= &c2c_he
->stats
;
824 total
= &hists
->stats
;
826 switch (c2c
.display
) {
828 st
= stats
->rmt_hitm
;
829 tot
= total
->rmt_hitm
;
832 st
= stats
->lcl_hitm
;
833 tot
= total
->lcl_hitm
;
836 st
= stats
->tot_hitm
;
837 tot
= total
->tot_hitm
;
842 p
= tot
? (double) st
/ tot
: 0;
847 #define PERC_STR(__s, __v) \
849 scnprintf(__s, sizeof(__s), "%.2F%%", __v); \
854 percent_hitm_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
855 struct hist_entry
*he
)
857 struct c2c_hist_entry
*c2c_he
;
858 int width
= c2c_width(fmt
, hpp
, he
->hists
);
862 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
863 per
= percent_hitm(c2c_he
);
864 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, PERC_STR(buf
, per
));
868 percent_hitm_color(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
869 struct hist_entry
*he
)
871 return percent_color(fmt
, hpp
, he
, percent_hitm
);
875 percent_hitm_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
876 struct hist_entry
*left
, struct hist_entry
*right
)
878 struct c2c_hist_entry
*c2c_left
;
879 struct c2c_hist_entry
*c2c_right
;
883 c2c_left
= container_of(left
, struct c2c_hist_entry
, he
);
884 c2c_right
= container_of(right
, struct c2c_hist_entry
, he
);
886 per_left
= percent_hitm(c2c_left
);
887 per_right
= percent_hitm(c2c_right
);
889 return per_left
- per_right
;
892 static struct c2c_stats
*he_stats(struct hist_entry
*he
)
894 struct c2c_hist_entry
*c2c_he
;
896 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
897 return &c2c_he
->stats
;
900 static struct c2c_stats
*total_stats(struct hist_entry
*he
)
902 struct c2c_hists
*hists
;
904 hists
= container_of(he
->hists
, struct c2c_hists
, hists
);
905 return &hists
->stats
;
908 static double percent(int st
, int tot
)
910 return tot
? 100. * (double) st
/ (double) tot
: 0;
913 #define PERCENT(__h, __f) percent(he_stats(__h)->__f, total_stats(__h)->__f)
915 #define PERCENT_FN(__f) \
916 static double percent_ ## __f(struct c2c_hist_entry *c2c_he) \
918 struct c2c_hists *hists; \
920 hists = container_of(c2c_he->he.hists, struct c2c_hists, hists); \
921 return percent(c2c_he->stats.__f, hists->stats.__f); \
927 PERCENT_FN(st_l1miss
)
930 percent_rmt_hitm_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
931 struct hist_entry
*he
)
933 int width
= c2c_width(fmt
, hpp
, he
->hists
);
934 double per
= PERCENT(he
, rmt_hitm
);
937 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, PERC_STR(buf
, per
));
941 percent_rmt_hitm_color(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
942 struct hist_entry
*he
)
944 return percent_color(fmt
, hpp
, he
, percent_rmt_hitm
);
948 percent_rmt_hitm_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
949 struct hist_entry
*left
, struct hist_entry
*right
)
954 per_left
= PERCENT(left
, lcl_hitm
);
955 per_right
= PERCENT(right
, lcl_hitm
);
957 return per_left
- per_right
;
961 percent_lcl_hitm_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
962 struct hist_entry
*he
)
964 int width
= c2c_width(fmt
, hpp
, he
->hists
);
965 double per
= PERCENT(he
, lcl_hitm
);
968 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, PERC_STR(buf
, per
));
972 percent_lcl_hitm_color(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
973 struct hist_entry
*he
)
975 return percent_color(fmt
, hpp
, he
, percent_lcl_hitm
);
979 percent_lcl_hitm_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
980 struct hist_entry
*left
, struct hist_entry
*right
)
985 per_left
= PERCENT(left
, lcl_hitm
);
986 per_right
= PERCENT(right
, lcl_hitm
);
988 return per_left
- per_right
;
992 percent_stores_l1hit_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
993 struct hist_entry
*he
)
995 int width
= c2c_width(fmt
, hpp
, he
->hists
);
996 double per
= PERCENT(he
, st_l1hit
);
999 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, PERC_STR(buf
, per
));
1003 percent_stores_l1hit_color(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1004 struct hist_entry
*he
)
1006 return percent_color(fmt
, hpp
, he
, percent_st_l1hit
);
1010 percent_stores_l1hit_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
1011 struct hist_entry
*left
, struct hist_entry
*right
)
1016 per_left
= PERCENT(left
, st_l1hit
);
1017 per_right
= PERCENT(right
, st_l1hit
);
1019 return per_left
- per_right
;
1023 percent_stores_l1miss_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1024 struct hist_entry
*he
)
1026 int width
= c2c_width(fmt
, hpp
, he
->hists
);
1027 double per
= PERCENT(he
, st_l1miss
);
1030 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, PERC_STR(buf
, per
));
1034 percent_stores_l1miss_color(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1035 struct hist_entry
*he
)
1037 return percent_color(fmt
, hpp
, he
, percent_st_l1miss
);
1041 percent_stores_l1miss_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
1042 struct hist_entry
*left
, struct hist_entry
*right
)
1047 per_left
= PERCENT(left
, st_l1miss
);
1048 per_right
= PERCENT(right
, st_l1miss
);
1050 return per_left
- per_right
;
1057 pid_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1058 struct hist_entry
*he
)
1060 int width
= c2c_width(fmt
, hpp
, he
->hists
);
1062 return scnprintf(hpp
->buf
, hpp
->size
, "%*d", width
, he
->thread
->pid_
);
1066 pid_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
1067 struct hist_entry
*left
, struct hist_entry
*right
)
1069 return left
->thread
->pid_
- right
->thread
->pid_
;
1073 empty_cmp(struct perf_hpp_fmt
*fmt __maybe_unused
,
1074 struct hist_entry
*left __maybe_unused
,
1075 struct hist_entry
*right __maybe_unused
)
1081 node_entry(struct perf_hpp_fmt
*fmt __maybe_unused
, struct perf_hpp
*hpp
,
1082 struct hist_entry
*he
)
1084 struct c2c_hist_entry
*c2c_he
;
1089 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
1091 for (node
= 0; node
< c2c
.nodes_cnt
; node
++) {
1092 DECLARE_BITMAP(set
, c2c
.cpus_cnt
);
1094 bitmap_zero(set
, c2c
.cpus_cnt
);
1095 bitmap_and(set
, c2c_he
->cpuset
, c2c
.nodes
[node
], c2c
.cpus_cnt
);
1097 if (!bitmap_weight(set
, c2c
.cpus_cnt
)) {
1098 if (c2c
.node_info
== 1) {
1099 ret
= scnprintf(hpp
->buf
, hpp
->size
, "%21s", " ");
1100 advance_hpp(hpp
, ret
);
1106 ret
= scnprintf(hpp
->buf
, hpp
->size
, " ");
1107 advance_hpp(hpp
, ret
);
1110 switch (c2c
.node_info
) {
1112 ret
= scnprintf(hpp
->buf
, hpp
->size
, "%2d", node
);
1113 advance_hpp(hpp
, ret
);
1117 int num
= bitmap_weight(set
, c2c
.cpus_cnt
);
1118 struct c2c_stats
*stats
= &c2c_he
->node_stats
[node
];
1120 ret
= scnprintf(hpp
->buf
, hpp
->size
, "%2d{%2d ", node
, num
);
1121 advance_hpp(hpp
, ret
);
1123 #define DISPLAY_HITM(__h) \
1124 if (c2c_he->stats.__h> 0) { \
1125 ret = scnprintf(hpp->buf, hpp->size, "%5.1f%% ", \
1126 percent(stats->__h, c2c_he->stats.__h));\
1128 ret = scnprintf(hpp->buf, hpp->size, "%6s ", "n/a"); \
1131 switch (c2c
.display
) {
1133 DISPLAY_HITM(rmt_hitm
);
1136 DISPLAY_HITM(lcl_hitm
);
1139 DISPLAY_HITM(tot_hitm
);
1146 advance_hpp(hpp
, ret
);
1148 if (c2c_he
->stats
.store
> 0) {
1149 ret
= scnprintf(hpp
->buf
, hpp
->size
, "%5.1f%%}",
1150 percent(stats
->store
, c2c_he
->stats
.store
));
1152 ret
= scnprintf(hpp
->buf
, hpp
->size
, "%6s}", "n/a");
1155 advance_hpp(hpp
, ret
);
1159 ret
= scnprintf(hpp
->buf
, hpp
->size
, "%2d{", node
);
1160 advance_hpp(hpp
, ret
);
1162 ret
= bitmap_scnprintf(set
, c2c
.cpus_cnt
, hpp
->buf
, hpp
->size
);
1163 advance_hpp(hpp
, ret
);
1165 ret
= scnprintf(hpp
->buf
, hpp
->size
, "}");
1166 advance_hpp(hpp
, ret
);
1179 mean_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1180 struct hist_entry
*he
, double mean
)
1182 int width
= c2c_width(fmt
, hpp
, he
->hists
);
1185 scnprintf(buf
, 10, "%6.0f", mean
);
1186 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, buf
);
1189 #define MEAN_ENTRY(__func, __val) \
1191 __func(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, struct hist_entry *he) \
1193 struct c2c_hist_entry *c2c_he; \
1194 c2c_he = container_of(he, struct c2c_hist_entry, he); \
1195 return mean_entry(fmt, hpp, he, avg_stats(&c2c_he->cstats.__val)); \
1198 MEAN_ENTRY(mean_rmt_entry
, rmt_hitm
);
1199 MEAN_ENTRY(mean_lcl_entry
, lcl_hitm
);
1200 MEAN_ENTRY(mean_load_entry
, load
);
1203 cpucnt_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1204 struct hist_entry
*he
)
1206 struct c2c_hist_entry
*c2c_he
;
1207 int width
= c2c_width(fmt
, hpp
, he
->hists
);
1210 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
1212 scnprintf(buf
, 10, "%d", bitmap_weight(c2c_he
->cpuset
, c2c
.cpus_cnt
));
1213 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, buf
);
1217 cl_idx_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1218 struct hist_entry
*he
)
1220 struct c2c_hist_entry
*c2c_he
;
1221 int width
= c2c_width(fmt
, hpp
, he
->hists
);
1224 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
1226 scnprintf(buf
, 10, "%u", c2c_he
->cacheline_idx
);
1227 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, buf
);
1231 cl_idx_empty_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1232 struct hist_entry
*he
)
1234 int width
= c2c_width(fmt
, hpp
, he
->hists
);
1236 return scnprintf(hpp
->buf
, hpp
->size
, "%*s", width
, "");
1239 #define HEADER_LOW(__h) \
1246 #define HEADER_BOTH(__h0, __h1) \
1256 #define HEADER_SPAN(__h0, __h1, __s) \
1267 #define HEADER_SPAN_LOW(__h) \
1274 static struct c2c_dimension dim_dcacheline
= {
1275 .header
= HEADER_SPAN("--- Cacheline ----", "Address", 2),
1276 .name
= "dcacheline",
1277 .cmp
= dcacheline_cmp
,
1278 .entry
= dcacheline_entry
,
1282 static struct c2c_dimension dim_dcacheline_node
= {
1283 .header
= HEADER_LOW("Node"),
1284 .name
= "dcacheline_node",
1286 .entry
= dcacheline_node_entry
,
1290 static struct c2c_dimension dim_dcacheline_count
= {
1291 .header
= HEADER_LOW("PA cnt"),
1292 .name
= "dcacheline_count",
1294 .entry
= dcacheline_node_count
,
1298 static struct c2c_header header_offset_tui
= HEADER_SPAN("-----", "Off", 2);
1300 static struct c2c_dimension dim_offset
= {
1301 .header
= HEADER_SPAN("--- Data address -", "Offset", 2),
1304 .entry
= offset_entry
,
1308 static struct c2c_dimension dim_offset_node
= {
1309 .header
= HEADER_LOW("Node"),
1310 .name
= "offset_node",
1312 .entry
= dcacheline_node_entry
,
1316 static struct c2c_dimension dim_iaddr
= {
1317 .header
= HEADER_LOW("Code address"),
1320 .entry
= iaddr_entry
,
1324 static struct c2c_dimension dim_tot_hitm
= {
1325 .header
= HEADER_SPAN("----- LLC Load Hitm -----", "Total", 2),
1327 .cmp
= tot_hitm_cmp
,
1328 .entry
= tot_hitm_entry
,
1332 static struct c2c_dimension dim_lcl_hitm
= {
1333 .header
= HEADER_SPAN_LOW("Lcl"),
1335 .cmp
= lcl_hitm_cmp
,
1336 .entry
= lcl_hitm_entry
,
1340 static struct c2c_dimension dim_rmt_hitm
= {
1341 .header
= HEADER_SPAN_LOW("Rmt"),
1343 .cmp
= rmt_hitm_cmp
,
1344 .entry
= rmt_hitm_entry
,
1348 static struct c2c_dimension dim_cl_rmt_hitm
= {
1349 .header
= HEADER_SPAN("----- HITM -----", "Rmt", 1),
1350 .name
= "cl_rmt_hitm",
1351 .cmp
= rmt_hitm_cmp
,
1352 .entry
= rmt_hitm_entry
,
1356 static struct c2c_dimension dim_cl_lcl_hitm
= {
1357 .header
= HEADER_SPAN_LOW("Lcl"),
1358 .name
= "cl_lcl_hitm",
1359 .cmp
= lcl_hitm_cmp
,
1360 .entry
= lcl_hitm_entry
,
1364 static struct c2c_dimension dim_stores
= {
1365 .header
= HEADER_SPAN("---- Store Reference ----", "Total", 2),
1368 .entry
= store_entry
,
1372 static struct c2c_dimension dim_stores_l1hit
= {
1373 .header
= HEADER_SPAN_LOW("L1Hit"),
1374 .name
= "stores_l1hit",
1375 .cmp
= st_l1hit_cmp
,
1376 .entry
= st_l1hit_entry
,
1380 static struct c2c_dimension dim_stores_l1miss
= {
1381 .header
= HEADER_SPAN_LOW("L1Miss"),
1382 .name
= "stores_l1miss",
1383 .cmp
= st_l1miss_cmp
,
1384 .entry
= st_l1miss_entry
,
1388 static struct c2c_dimension dim_cl_stores_l1hit
= {
1389 .header
= HEADER_SPAN("-- Store Refs --", "L1 Hit", 1),
1390 .name
= "cl_stores_l1hit",
1391 .cmp
= st_l1hit_cmp
,
1392 .entry
= st_l1hit_entry
,
1396 static struct c2c_dimension dim_cl_stores_l1miss
= {
1397 .header
= HEADER_SPAN_LOW("L1 Miss"),
1398 .name
= "cl_stores_l1miss",
1399 .cmp
= st_l1miss_cmp
,
1400 .entry
= st_l1miss_entry
,
1404 static struct c2c_dimension dim_ld_fbhit
= {
1405 .header
= HEADER_SPAN("----- Core Load Hit -----", "FB", 2),
1407 .cmp
= ld_fbhit_cmp
,
1408 .entry
= ld_fbhit_entry
,
1412 static struct c2c_dimension dim_ld_l1hit
= {
1413 .header
= HEADER_SPAN_LOW("L1"),
1415 .cmp
= ld_l1hit_cmp
,
1416 .entry
= ld_l1hit_entry
,
1420 static struct c2c_dimension dim_ld_l2hit
= {
1421 .header
= HEADER_SPAN_LOW("L2"),
1423 .cmp
= ld_l2hit_cmp
,
1424 .entry
= ld_l2hit_entry
,
1428 static struct c2c_dimension dim_ld_llchit
= {
1429 .header
= HEADER_SPAN("-- LLC Load Hit --", "Llc", 1),
1430 .name
= "ld_lclhit",
1431 .cmp
= ld_llchit_cmp
,
1432 .entry
= ld_llchit_entry
,
1436 static struct c2c_dimension dim_ld_rmthit
= {
1437 .header
= HEADER_SPAN_LOW("Rmt"),
1438 .name
= "ld_rmthit",
1440 .entry
= rmt_hit_entry
,
1444 static struct c2c_dimension dim_ld_llcmiss
= {
1445 .header
= HEADER_BOTH("LLC", "Ld Miss"),
1446 .name
= "ld_llcmiss",
1447 .cmp
= ld_llcmiss_cmp
,
1448 .entry
= ld_llcmiss_entry
,
1452 static struct c2c_dimension dim_tot_recs
= {
1453 .header
= HEADER_BOTH("Total", "records"),
1455 .cmp
= tot_recs_cmp
,
1456 .entry
= tot_recs_entry
,
1460 static struct c2c_dimension dim_tot_loads
= {
1461 .header
= HEADER_BOTH("Total", "Loads"),
1462 .name
= "tot_loads",
1463 .cmp
= tot_loads_cmp
,
1464 .entry
= tot_loads_entry
,
1468 static struct c2c_header percent_hitm_header
[] = {
1469 [DISPLAY_LCL
] = HEADER_BOTH("Lcl", "Hitm"),
1470 [DISPLAY_RMT
] = HEADER_BOTH("Rmt", "Hitm"),
1471 [DISPLAY_TOT
] = HEADER_BOTH("Tot", "Hitm"),
1474 static struct c2c_dimension dim_percent_hitm
= {
1475 .name
= "percent_hitm",
1476 .cmp
= percent_hitm_cmp
,
1477 .entry
= percent_hitm_entry
,
1478 .color
= percent_hitm_color
,
1482 static struct c2c_dimension dim_percent_rmt_hitm
= {
1483 .header
= HEADER_SPAN("----- HITM -----", "Rmt", 1),
1484 .name
= "percent_rmt_hitm",
1485 .cmp
= percent_rmt_hitm_cmp
,
1486 .entry
= percent_rmt_hitm_entry
,
1487 .color
= percent_rmt_hitm_color
,
1491 static struct c2c_dimension dim_percent_lcl_hitm
= {
1492 .header
= HEADER_SPAN_LOW("Lcl"),
1493 .name
= "percent_lcl_hitm",
1494 .cmp
= percent_lcl_hitm_cmp
,
1495 .entry
= percent_lcl_hitm_entry
,
1496 .color
= percent_lcl_hitm_color
,
1500 static struct c2c_dimension dim_percent_stores_l1hit
= {
1501 .header
= HEADER_SPAN("-- Store Refs --", "L1 Hit", 1),
1502 .name
= "percent_stores_l1hit",
1503 .cmp
= percent_stores_l1hit_cmp
,
1504 .entry
= percent_stores_l1hit_entry
,
1505 .color
= percent_stores_l1hit_color
,
1509 static struct c2c_dimension dim_percent_stores_l1miss
= {
1510 .header
= HEADER_SPAN_LOW("L1 Miss"),
1511 .name
= "percent_stores_l1miss",
1512 .cmp
= percent_stores_l1miss_cmp
,
1513 .entry
= percent_stores_l1miss_entry
,
1514 .color
= percent_stores_l1miss_color
,
1518 static struct c2c_dimension dim_dram_lcl
= {
1519 .header
= HEADER_SPAN("--- Load Dram ----", "Lcl", 1),
1521 .cmp
= lcl_dram_cmp
,
1522 .entry
= lcl_dram_entry
,
1526 static struct c2c_dimension dim_dram_rmt
= {
1527 .header
= HEADER_SPAN_LOW("Rmt"),
1529 .cmp
= rmt_dram_cmp
,
1530 .entry
= rmt_dram_entry
,
1534 static struct c2c_dimension dim_pid
= {
1535 .header
= HEADER_LOW("Pid"),
1542 static struct c2c_dimension dim_tid
= {
1543 .header
= HEADER_LOW("Tid"),
1548 static struct c2c_dimension dim_symbol
= {
1553 static struct c2c_dimension dim_dso
= {
1554 .header
= HEADER_BOTH("Shared", "Object"),
1559 static struct c2c_header header_node
[3] = {
1561 HEADER_LOW("Node{cpus %hitms %stores}"),
1562 HEADER_LOW("Node{cpu list}"),
1565 static struct c2c_dimension dim_node
= {
1568 .entry
= node_entry
,
1572 static struct c2c_dimension dim_mean_rmt
= {
1573 .header
= HEADER_SPAN("---------- cycles ----------", "rmt hitm", 2),
1576 .entry
= mean_rmt_entry
,
1580 static struct c2c_dimension dim_mean_lcl
= {
1581 .header
= HEADER_SPAN_LOW("lcl hitm"),
1584 .entry
= mean_lcl_entry
,
1588 static struct c2c_dimension dim_mean_load
= {
1589 .header
= HEADER_SPAN_LOW("load"),
1590 .name
= "mean_load",
1592 .entry
= mean_load_entry
,
1596 static struct c2c_dimension dim_cpucnt
= {
1597 .header
= HEADER_BOTH("cpu", "cnt"),
1600 .entry
= cpucnt_entry
,
1604 static struct c2c_dimension dim_srcline
= {
1605 .name
= "cl_srcline",
1606 .se
= &sort_srcline
,
1609 static struct c2c_dimension dim_dcacheline_idx
= {
1610 .header
= HEADER_LOW("Index"),
1613 .entry
= cl_idx_entry
,
1617 static struct c2c_dimension dim_dcacheline_num
= {
1618 .header
= HEADER_LOW("Num"),
1621 .entry
= cl_idx_entry
,
1625 static struct c2c_dimension dim_dcacheline_num_empty
= {
1626 .header
= HEADER_LOW("Num"),
1627 .name
= "cl_num_empty",
1629 .entry
= cl_idx_empty_entry
,
1633 static struct c2c_dimension
*dimensions
[] = {
1635 &dim_dcacheline_node
,
1636 &dim_dcacheline_count
,
1648 &dim_cl_stores_l1hit
,
1649 &dim_cl_stores_l1miss
,
1659 &dim_percent_rmt_hitm
,
1660 &dim_percent_lcl_hitm
,
1661 &dim_percent_stores_l1hit
,
1662 &dim_percent_stores_l1miss
,
1675 &dim_dcacheline_idx
,
1676 &dim_dcacheline_num
,
1677 &dim_dcacheline_num_empty
,
1681 static void fmt_free(struct perf_hpp_fmt
*fmt
)
1683 struct c2c_fmt
*c2c_fmt
;
1685 c2c_fmt
= container_of(fmt
, struct c2c_fmt
, fmt
);
1689 static bool fmt_equal(struct perf_hpp_fmt
*a
, struct perf_hpp_fmt
*b
)
1691 struct c2c_fmt
*c2c_a
= container_of(a
, struct c2c_fmt
, fmt
);
1692 struct c2c_fmt
*c2c_b
= container_of(b
, struct c2c_fmt
, fmt
);
1694 return c2c_a
->dim
== c2c_b
->dim
;
1697 static struct c2c_dimension
*get_dimension(const char *name
)
1701 for (i
= 0; dimensions
[i
]; i
++) {
1702 struct c2c_dimension
*dim
= dimensions
[i
];
1704 if (!strcmp(dim
->name
, name
))
1711 static int c2c_se_entry(struct perf_hpp_fmt
*fmt
, struct perf_hpp
*hpp
,
1712 struct hist_entry
*he
)
1714 struct c2c_fmt
*c2c_fmt
= container_of(fmt
, struct c2c_fmt
, fmt
);
1715 struct c2c_dimension
*dim
= c2c_fmt
->dim
;
1716 size_t len
= fmt
->user_len
;
1719 len
= hists__col_len(he
->hists
, dim
->se
->se_width_idx
);
1721 if (dim
== &dim_symbol
|| dim
== &dim_srcline
)
1722 len
= symbol_width(he
->hists
, dim
->se
);
1725 return dim
->se
->se_snprintf(he
, hpp
->buf
, hpp
->size
, len
);
1728 static int64_t c2c_se_cmp(struct perf_hpp_fmt
*fmt
,
1729 struct hist_entry
*a
, struct hist_entry
*b
)
1731 struct c2c_fmt
*c2c_fmt
= container_of(fmt
, struct c2c_fmt
, fmt
);
1732 struct c2c_dimension
*dim
= c2c_fmt
->dim
;
1734 return dim
->se
->se_cmp(a
, b
);
1737 static int64_t c2c_se_collapse(struct perf_hpp_fmt
*fmt
,
1738 struct hist_entry
*a
, struct hist_entry
*b
)
1740 struct c2c_fmt
*c2c_fmt
= container_of(fmt
, struct c2c_fmt
, fmt
);
1741 struct c2c_dimension
*dim
= c2c_fmt
->dim
;
1742 int64_t (*collapse_fn
)(struct hist_entry
*, struct hist_entry
*);
1744 collapse_fn
= dim
->se
->se_collapse
?: dim
->se
->se_cmp
;
1745 return collapse_fn(a
, b
);
1748 static struct c2c_fmt
*get_format(const char *name
)
1750 struct c2c_dimension
*dim
= get_dimension(name
);
1751 struct c2c_fmt
*c2c_fmt
;
1752 struct perf_hpp_fmt
*fmt
;
1757 c2c_fmt
= zalloc(sizeof(*c2c_fmt
));
1763 fmt
= &c2c_fmt
->fmt
;
1764 INIT_LIST_HEAD(&fmt
->list
);
1765 INIT_LIST_HEAD(&fmt
->sort_list
);
1767 fmt
->cmp
= dim
->se
? c2c_se_cmp
: dim
->cmp
;
1768 fmt
->sort
= dim
->se
? c2c_se_cmp
: dim
->cmp
;
1769 fmt
->color
= dim
->se
? NULL
: dim
->color
;
1770 fmt
->entry
= dim
->se
? c2c_se_entry
: dim
->entry
;
1771 fmt
->header
= c2c_header
;
1772 fmt
->width
= c2c_width
;
1773 fmt
->collapse
= dim
->se
? c2c_se_collapse
: dim
->cmp
;
1774 fmt
->equal
= fmt_equal
;
1775 fmt
->free
= fmt_free
;
1780 static int c2c_hists__init_output(struct perf_hpp_list
*hpp_list
, char *name
)
1782 struct c2c_fmt
*c2c_fmt
= get_format(name
);
1786 return output_field_add(hpp_list
, name
);
1789 perf_hpp_list__column_register(hpp_list
, &c2c_fmt
->fmt
);
1793 static int c2c_hists__init_sort(struct perf_hpp_list
*hpp_list
, char *name
)
1795 struct c2c_fmt
*c2c_fmt
= get_format(name
);
1796 struct c2c_dimension
*dim
;
1800 return sort_dimension__add(hpp_list
, name
, NULL
, 0);
1804 if (dim
== &dim_dso
)
1807 perf_hpp_list__register_sort_field(hpp_list
, &c2c_fmt
->fmt
);
1811 #define PARSE_LIST(_list, _fn) \
1819 for (tok = strtok_r((char *)_list, ", ", &tmp); \
1820 tok; tok = strtok_r(NULL, ", ", &tmp)) { \
1821 ret = _fn(hpp_list, tok); \
1822 if (ret == -EINVAL) { \
1823 pr_err("Invalid --fields key: `%s'", tok); \
1825 } else if (ret == -ESRCH) { \
1826 pr_err("Unknown --fields key: `%s'", tok); \
1832 static int hpp_list__parse(struct perf_hpp_list
*hpp_list
,
1833 const char *output_
,
1836 char *output
= output_
? strdup(output_
) : NULL
;
1837 char *sort
= sort_
? strdup(sort_
) : NULL
;
1840 PARSE_LIST(output
, c2c_hists__init_output
);
1841 PARSE_LIST(sort
, c2c_hists__init_sort
);
1843 /* copy sort keys to output fields */
1844 perf_hpp__setup_output_field(hpp_list
);
1847 * We dont need other sorting keys other than those
1848 * we already specified. It also really slows down
1849 * the processing a lot with big number of output
1850 * fields, so switching this off for c2c.
1854 /* and then copy output fields to sort keys */
1855 perf_hpp__append_sort_keys(&hists
->list
);
1863 static int c2c_hists__init(struct c2c_hists
*hists
,
1865 int nr_header_lines
)
1867 __hists__init(&hists
->hists
, &hists
->list
);
1870 * Initialize only with sort fields, we need to resort
1871 * later anyway, and that's where we add output fields
1874 perf_hpp_list__init(&hists
->list
);
1876 /* Overload number of header lines.*/
1877 hists
->list
.nr_header_lines
= nr_header_lines
;
1879 return hpp_list__parse(&hists
->list
, NULL
, sort
);
1882 static int c2c_hists__reinit(struct c2c_hists
*c2c_hists
,
1886 perf_hpp__reset_output_field(&c2c_hists
->list
);
1887 return hpp_list__parse(&c2c_hists
->list
, output
, sort
);
1890 #define DISPLAY_LINE_LIMIT 0.001
1892 static bool he__display(struct hist_entry
*he
, struct c2c_stats
*stats
)
1894 struct c2c_hist_entry
*c2c_he
;
1900 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
1902 #define FILTER_HITM(__h) \
1904 ld_dist = ((double)c2c_he->stats.__h / stats->__h); \
1905 if (ld_dist < DISPLAY_LINE_LIMIT) \
1906 he->filtered = HIST_FILTER__C2C; \
1908 he->filtered = HIST_FILTER__C2C; \
1911 switch (c2c
.display
) {
1913 FILTER_HITM(lcl_hitm
);
1916 FILTER_HITM(rmt_hitm
);
1919 FILTER_HITM(tot_hitm
);
1926 return he
->filtered
== 0;
1929 static inline int valid_hitm_or_store(struct hist_entry
*he
)
1931 struct c2c_hist_entry
*c2c_he
;
1934 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
1935 has_hitm
= c2c
.display
== DISPLAY_TOT
? c2c_he
->stats
.tot_hitm
:
1936 c2c
.display
== DISPLAY_LCL
? c2c_he
->stats
.lcl_hitm
:
1937 c2c_he
->stats
.rmt_hitm
;
1938 return has_hitm
|| c2c_he
->stats
.store
;
1941 static void set_node_width(struct c2c_hist_entry
*c2c_he
, int len
)
1943 struct c2c_dimension
*dim
;
1945 dim
= &c2c
.hists
== c2c_he
->hists
?
1946 &dim_dcacheline_node
: &dim_offset_node
;
1948 if (len
> dim
->width
)
1952 static int set_nodestr(struct c2c_hist_entry
*c2c_he
)
1957 if (c2c_he
->nodestr
)
1960 if (bitmap_weight(c2c_he
->nodeset
, c2c
.nodes_cnt
)) {
1961 len
= bitmap_scnprintf(c2c_he
->nodeset
, c2c
.nodes_cnt
,
1964 len
= scnprintf(buf
, sizeof(buf
), "N/A");
1967 set_node_width(c2c_he
, len
);
1968 c2c_he
->nodestr
= strdup(buf
);
1969 return c2c_he
->nodestr
? 0 : -ENOMEM
;
1972 static void calc_width(struct c2c_hist_entry
*c2c_he
)
1974 struct c2c_hists
*c2c_hists
;
1976 c2c_hists
= container_of(c2c_he
->he
.hists
, struct c2c_hists
, hists
);
1977 hists__calc_col_len(&c2c_hists
->hists
, &c2c_he
->he
);
1978 set_nodestr(c2c_he
);
1981 static int filter_cb(struct hist_entry
*he
, void *arg __maybe_unused
)
1983 struct c2c_hist_entry
*c2c_he
;
1985 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
1987 if (c2c
.show_src
&& !he
->srcline
)
1988 he
->srcline
= hist_entry__srcline(he
);
1992 if (!valid_hitm_or_store(he
))
1993 he
->filtered
= HIST_FILTER__C2C
;
1998 static int resort_cl_cb(struct hist_entry
*he
, void *arg __maybe_unused
)
2000 struct c2c_hist_entry
*c2c_he
;
2001 struct c2c_hists
*c2c_hists
;
2002 bool display
= he__display(he
, &c2c
.hitm_stats
);
2004 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
2005 c2c_hists
= c2c_he
->hists
;
2007 if (display
&& c2c_hists
) {
2008 static unsigned int idx
;
2010 c2c_he
->cacheline_idx
= idx
++;
2013 c2c_hists__reinit(c2c_hists
, c2c
.cl_output
, c2c
.cl_resort
);
2015 hists__collapse_resort(&c2c_hists
->hists
, NULL
);
2016 hists__output_resort_cb(&c2c_hists
->hists
, NULL
, filter_cb
);
2022 static void setup_nodes_header(void)
2024 dim_node
.header
= header_node
[c2c
.node_info
];
2027 static int setup_nodes(struct perf_session
*session
)
2029 struct numa_node
*n
;
2030 unsigned long **nodes
;
2034 if (c2c
.node_info
> 2)
2037 c2c
.nodes_cnt
= session
->header
.env
.nr_numa_nodes
;
2038 c2c
.cpus_cnt
= session
->header
.env
.nr_cpus_avail
;
2040 n
= session
->header
.env
.numa_nodes
;
2044 nodes
= zalloc(sizeof(unsigned long *) * c2c
.nodes_cnt
);
2050 cpu2node
= zalloc(sizeof(int) * c2c
.cpus_cnt
);
2054 for (cpu
= 0; cpu
< c2c
.cpus_cnt
; cpu
++)
2057 c2c
.cpu2node
= cpu2node
;
2059 for (node
= 0; node
< c2c
.nodes_cnt
; node
++) {
2060 struct perf_cpu_map
*map
= n
[node
].map
;
2063 set
= bitmap_alloc(c2c
.cpus_cnt
);
2069 /* empty node, skip */
2070 if (perf_cpu_map__empty(map
))
2073 for (cpu
= 0; cpu
< map
->nr
; cpu
++) {
2074 set_bit(map
->map
[cpu
], set
);
2076 if (WARN_ONCE(cpu2node
[map
->map
[cpu
]] != -1, "node/cpu topology bug"))
2079 cpu2node
[map
->map
[cpu
]] = node
;
2083 setup_nodes_header();
2087 #define HAS_HITMS(__h) ((__h)->stats.lcl_hitm || (__h)->stats.rmt_hitm)
2089 static int resort_hitm_cb(struct hist_entry
*he
, void *arg __maybe_unused
)
2091 struct c2c_hist_entry
*c2c_he
;
2092 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
2094 if (HAS_HITMS(c2c_he
)) {
2095 c2c
.shared_clines
++;
2096 c2c_add_stats(&c2c
.hitm_stats
, &c2c_he
->stats
);
2102 static int hists__iterate_cb(struct hists
*hists
, hists__resort_cb_t cb
)
2104 struct rb_node
*next
= rb_first_cached(&hists
->entries
);
2108 struct hist_entry
*he
;
2110 he
= rb_entry(next
, struct hist_entry
, rb_node
);
2114 next
= rb_next(&he
->rb_node
);
2120 static void print_c2c__display_stats(FILE *out
)
2123 struct c2c_stats
*stats
= &c2c
.hists
.stats
;
2125 llc_misses
= stats
->lcl_dram
+
2130 fprintf(out
, "=================================================\n");
2131 fprintf(out
, " Trace Event Information \n");
2132 fprintf(out
, "=================================================\n");
2133 fprintf(out
, " Total records : %10d\n", stats
->nr_entries
);
2134 fprintf(out
, " Locked Load/Store Operations : %10d\n", stats
->locks
);
2135 fprintf(out
, " Load Operations : %10d\n", stats
->load
);
2136 fprintf(out
, " Loads - uncacheable : %10d\n", stats
->ld_uncache
);
2137 fprintf(out
, " Loads - IO : %10d\n", stats
->ld_io
);
2138 fprintf(out
, " Loads - Miss : %10d\n", stats
->ld_miss
);
2139 fprintf(out
, " Loads - no mapping : %10d\n", stats
->ld_noadrs
);
2140 fprintf(out
, " Load Fill Buffer Hit : %10d\n", stats
->ld_fbhit
);
2141 fprintf(out
, " Load L1D hit : %10d\n", stats
->ld_l1hit
);
2142 fprintf(out
, " Load L2D hit : %10d\n", stats
->ld_l2hit
);
2143 fprintf(out
, " Load LLC hit : %10d\n", stats
->ld_llchit
+ stats
->lcl_hitm
);
2144 fprintf(out
, " Load Local HITM : %10d\n", stats
->lcl_hitm
);
2145 fprintf(out
, " Load Remote HITM : %10d\n", stats
->rmt_hitm
);
2146 fprintf(out
, " Load Remote HIT : %10d\n", stats
->rmt_hit
);
2147 fprintf(out
, " Load Local DRAM : %10d\n", stats
->lcl_dram
);
2148 fprintf(out
, " Load Remote DRAM : %10d\n", stats
->rmt_dram
);
2149 fprintf(out
, " Load MESI State Exclusive : %10d\n", stats
->ld_excl
);
2150 fprintf(out
, " Load MESI State Shared : %10d\n", stats
->ld_shared
);
2151 fprintf(out
, " Load LLC Misses : %10d\n", llc_misses
);
2152 fprintf(out
, " LLC Misses to Local DRAM : %10.1f%%\n", ((double)stats
->lcl_dram
/(double)llc_misses
) * 100.);
2153 fprintf(out
, " LLC Misses to Remote DRAM : %10.1f%%\n", ((double)stats
->rmt_dram
/(double)llc_misses
) * 100.);
2154 fprintf(out
, " LLC Misses to Remote cache (HIT) : %10.1f%%\n", ((double)stats
->rmt_hit
/(double)llc_misses
) * 100.);
2155 fprintf(out
, " LLC Misses to Remote cache (HITM) : %10.1f%%\n", ((double)stats
->rmt_hitm
/(double)llc_misses
) * 100.);
2156 fprintf(out
, " Store Operations : %10d\n", stats
->store
);
2157 fprintf(out
, " Store - uncacheable : %10d\n", stats
->st_uncache
);
2158 fprintf(out
, " Store - no mapping : %10d\n", stats
->st_noadrs
);
2159 fprintf(out
, " Store L1D Hit : %10d\n", stats
->st_l1hit
);
2160 fprintf(out
, " Store L1D Miss : %10d\n", stats
->st_l1miss
);
2161 fprintf(out
, " No Page Map Rejects : %10d\n", stats
->nomap
);
2162 fprintf(out
, " Unable to parse data source : %10d\n", stats
->noparse
);
2165 static void print_shared_cacheline_info(FILE *out
)
2167 struct c2c_stats
*stats
= &c2c
.hitm_stats
;
2168 int hitm_cnt
= stats
->lcl_hitm
+ stats
->rmt_hitm
;
2170 fprintf(out
, "=================================================\n");
2171 fprintf(out
, " Global Shared Cache Line Event Information \n");
2172 fprintf(out
, "=================================================\n");
2173 fprintf(out
, " Total Shared Cache Lines : %10d\n", c2c
.shared_clines
);
2174 fprintf(out
, " Load HITs on shared lines : %10d\n", stats
->load
);
2175 fprintf(out
, " Fill Buffer Hits on shared lines : %10d\n", stats
->ld_fbhit
);
2176 fprintf(out
, " L1D hits on shared lines : %10d\n", stats
->ld_l1hit
);
2177 fprintf(out
, " L2D hits on shared lines : %10d\n", stats
->ld_l2hit
);
2178 fprintf(out
, " LLC hits on shared lines : %10d\n", stats
->ld_llchit
+ stats
->lcl_hitm
);
2179 fprintf(out
, " Locked Access on shared lines : %10d\n", stats
->locks
);
2180 fprintf(out
, " Store HITs on shared lines : %10d\n", stats
->store
);
2181 fprintf(out
, " Store L1D hits on shared lines : %10d\n", stats
->st_l1hit
);
2182 fprintf(out
, " Total Merged records : %10d\n", hitm_cnt
+ stats
->store
);
2185 static void print_cacheline(struct c2c_hists
*c2c_hists
,
2186 struct hist_entry
*he_cl
,
2187 struct perf_hpp_list
*hpp_list
,
2191 struct perf_hpp hpp
= {
2198 hists__fprintf_headers(&c2c_hists
->hists
, out
);
2204 fprintf(out
, " -------------------------------------------------------------\n");
2205 __hist_entry__snprintf(he_cl
, &hpp
, hpp_list
);
2206 fprintf(out
, "%s\n", bf
);
2207 fprintf(out
, " -------------------------------------------------------------\n");
2209 hists__fprintf(&c2c_hists
->hists
, false, 0, 0, 0, out
, false);
2212 static void print_pareto(FILE *out
)
2214 struct perf_hpp_list hpp_list
;
2218 perf_hpp_list__init(&hpp_list
);
2219 ret
= hpp_list__parse(&hpp_list
,
2228 if (WARN_ONCE(ret
, "failed to setup sort entries\n"))
2231 nd
= rb_first_cached(&c2c
.hists
.hists
.entries
);
2233 for (; nd
; nd
= rb_next(nd
)) {
2234 struct hist_entry
*he
= rb_entry(nd
, struct hist_entry
, rb_node
);
2235 struct c2c_hist_entry
*c2c_he
;
2240 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
2241 print_cacheline(c2c_he
->hists
, he
, &hpp_list
, out
);
2245 static void print_c2c_info(FILE *out
, struct perf_session
*session
)
2247 struct evlist
*evlist
= session
->evlist
;
2248 struct evsel
*evsel
;
2251 fprintf(out
, "=================================================\n");
2252 fprintf(out
, " c2c details \n");
2253 fprintf(out
, "=================================================\n");
2255 evlist__for_each_entry(evlist
, evsel
) {
2256 fprintf(out
, "%-36s: %s\n", first
? " Events" : "",
2257 perf_evsel__name(evsel
));
2260 fprintf(out
, " Cachelines sort on : %s HITMs\n",
2261 display_str
[c2c
.display
]);
2262 fprintf(out
, " Cacheline data grouping : %s\n", c2c
.cl_sort
);
2265 static void perf_c2c__hists_fprintf(FILE *out
, struct perf_session
*session
)
2269 print_c2c__display_stats(out
);
2271 print_shared_cacheline_info(out
);
2273 print_c2c_info(out
, session
);
2279 fprintf(out
, "=================================================\n");
2280 fprintf(out
, " Shared Data Cache Line Table \n");
2281 fprintf(out
, "=================================================\n");
2282 fprintf(out
, "#\n");
2284 hists__fprintf(&c2c
.hists
.hists
, true, 0, 0, 0, stdout
, true);
2287 fprintf(out
, "=================================================\n");
2288 fprintf(out
, " Shared Cache Line Distribution Pareto \n");
2289 fprintf(out
, "=================================================\n");
2290 fprintf(out
, "#\n");
2295 #ifdef HAVE_SLANG_SUPPORT
2296 static void c2c_browser__update_nr_entries(struct hist_browser
*hb
)
2299 struct rb_node
*nd
= rb_first_cached(&hb
->hists
->entries
);
2302 struct hist_entry
*he
= rb_entry(nd
, struct hist_entry
, rb_node
);
2310 hb
->nr_non_filtered_entries
= nr_entries
;
2313 struct c2c_cacheline_browser
{
2314 struct hist_browser hb
;
2315 struct hist_entry
*he
;
2319 perf_c2c_cacheline_browser__title(struct hist_browser
*browser
,
2320 char *bf
, size_t size
)
2322 struct c2c_cacheline_browser
*cl_browser
;
2323 struct hist_entry
*he
;
2326 cl_browser
= container_of(browser
, struct c2c_cacheline_browser
, hb
);
2327 he
= cl_browser
->he
;
2330 addr
= cl_address(he
->mem_info
->daddr
.addr
);
2332 scnprintf(bf
, size
, "Cacheline 0x%lx", addr
);
2336 static struct c2c_cacheline_browser
*
2337 c2c_cacheline_browser__new(struct hists
*hists
, struct hist_entry
*he
)
2339 struct c2c_cacheline_browser
*browser
;
2341 browser
= zalloc(sizeof(*browser
));
2343 hist_browser__init(&browser
->hb
, hists
);
2344 browser
->hb
.c2c_filter
= true;
2345 browser
->hb
.title
= perf_c2c_cacheline_browser__title
;
2352 static int perf_c2c__browse_cacheline(struct hist_entry
*he
)
2354 struct c2c_hist_entry
*c2c_he
;
2355 struct c2c_hists
*c2c_hists
;
2356 struct c2c_cacheline_browser
*cl_browser
;
2357 struct hist_browser
*browser
;
2359 static const char help
[] =
2360 " ENTER Toggle callchains (if present) \n"
2361 " n Toggle Node details info \n"
2362 " s Toggle full length of symbol and source line columns \n"
2363 " q Return back to cacheline list \n";
2368 /* Display compact version first. */
2369 c2c
.symbol_full
= false;
2371 c2c_he
= container_of(he
, struct c2c_hist_entry
, he
);
2372 c2c_hists
= c2c_he
->hists
;
2374 cl_browser
= c2c_cacheline_browser__new(&c2c_hists
->hists
, he
);
2375 if (cl_browser
== NULL
)
2378 browser
= &cl_browser
->hb
;
2380 /* reset abort key so that it can get Ctrl-C as a key */
2382 SLang_init_tty(0, 0, 0);
2384 c2c_browser__update_nr_entries(browser
);
2387 key
= hist_browser__run(browser
, "? - help", true);
2391 c2c
.symbol_full
= !c2c
.symbol_full
;
2394 c2c
.node_info
= (c2c
.node_info
+ 1) % 3;
2395 setup_nodes_header();
2400 ui_browser__help_window(&browser
->b
, help
);
2412 static int perf_c2c_browser__title(struct hist_browser
*browser
,
2413 char *bf
, size_t size
)
2416 "Shared Data Cache Line Table "
2417 "(%lu entries, sorted on %s HITMs)",
2418 browser
->nr_non_filtered_entries
,
2419 display_str
[c2c
.display
]);
2423 static struct hist_browser
*
2424 perf_c2c_browser__new(struct hists
*hists
)
2426 struct hist_browser
*browser
= hist_browser__new(hists
);
2429 browser
->title
= perf_c2c_browser__title
;
2430 browser
->c2c_filter
= true;
2436 static int perf_c2c__hists_browse(struct hists
*hists
)
2438 struct hist_browser
*browser
;
2440 static const char help
[] =
2441 " d Display cacheline details \n"
2442 " ENTER Toggle callchains (if present) \n"
2445 browser
= perf_c2c_browser__new(hists
);
2446 if (browser
== NULL
)
2449 /* reset abort key so that it can get Ctrl-C as a key */
2451 SLang_init_tty(0, 0, 0);
2453 c2c_browser__update_nr_entries(browser
);
2456 key
= hist_browser__run(browser
, "? - help", true);
2462 perf_c2c__browse_cacheline(browser
->he_selection
);
2465 ui_browser__help_window(&browser
->b
, help
);
2473 hist_browser__delete(browser
);
2477 static void perf_c2c_display(struct perf_session
*session
)
2479 if (use_browser
== 0)
2480 perf_c2c__hists_fprintf(stdout
, session
);
2482 perf_c2c__hists_browse(&c2c
.hists
.hists
);
2485 static void perf_c2c_display(struct perf_session
*session
)
2488 perf_c2c__hists_fprintf(stdout
, session
);
2490 #endif /* HAVE_SLANG_SUPPORT */
2492 static char *fill_line(const char *orig
, int len
)
2494 int i
, j
, olen
= strlen(orig
);
2497 buf
= zalloc(len
+ 1);
2501 j
= len
/ 2 - olen
/ 2;
2503 for (i
= 0; i
< j
- 1; i
++)
2508 strcpy(buf
+ i
, orig
);
2514 for (; i
< len
; i
++)
2520 static int ui_quirks(void)
2522 const char *nodestr
= "Data address";
2525 if (!c2c
.use_stdio
) {
2526 dim_offset
.width
= 5;
2527 dim_offset
.header
= header_offset_tui
;
2531 dim_percent_hitm
.header
= percent_hitm_header
[c2c
.display
];
2533 /* Fix the zero line for dcacheline column. */
2534 buf
= fill_line("Cacheline", dim_dcacheline
.width
+
2535 dim_dcacheline_node
.width
+
2536 dim_dcacheline_count
.width
+ 4);
2540 dim_dcacheline
.header
.line
[0].text
= buf
;
2542 /* Fix the zero line for offset column. */
2543 buf
= fill_line(nodestr
, dim_offset
.width
+
2544 dim_offset_node
.width
+
2545 dim_dcacheline_count
.width
+ 4);
2549 dim_offset
.header
.line
[0].text
= buf
;
2554 #define CALLCHAIN_DEFAULT_OPT "graph,0.5,caller,function,percent"
2556 const char callchain_help
[] = "Display call graph (stack chain/backtrace):\n\n"
2557 CALLCHAIN_REPORT_HELP
2558 "\n\t\t\t\tDefault: " CALLCHAIN_DEFAULT_OPT
;
2561 parse_callchain_opt(const struct option
*opt
, const char *arg
, int unset
)
2563 struct callchain_param
*callchain
= opt
->value
;
2565 callchain
->enabled
= !unset
;
2570 symbol_conf
.use_callchain
= false;
2571 callchain
->mode
= CHAIN_NONE
;
2575 return parse_callchain_report_opt(arg
);
2578 static int setup_callchain(struct evlist
*evlist
)
2580 u64 sample_type
= perf_evlist__combined_sample_type(evlist
);
2581 enum perf_call_graph_mode mode
= CALLCHAIN_NONE
;
2583 if ((sample_type
& PERF_SAMPLE_REGS_USER
) &&
2584 (sample_type
& PERF_SAMPLE_STACK_USER
)) {
2585 mode
= CALLCHAIN_DWARF
;
2586 dwarf_callchain_users
= true;
2587 } else if (sample_type
& PERF_SAMPLE_BRANCH_STACK
)
2588 mode
= CALLCHAIN_LBR
;
2589 else if (sample_type
& PERF_SAMPLE_CALLCHAIN
)
2590 mode
= CALLCHAIN_FP
;
2592 if (!callchain_param
.enabled
&&
2593 callchain_param
.mode
!= CHAIN_NONE
&&
2594 mode
!= CALLCHAIN_NONE
) {
2595 symbol_conf
.use_callchain
= true;
2596 if (callchain_register_param(&callchain_param
) < 0) {
2597 ui__error("Can't register callchain params.\n");
2602 callchain_param
.record_mode
= mode
;
2603 callchain_param
.min_percent
= 0;
2607 static int setup_display(const char *str
)
2609 const char *display
= str
?: "tot";
2611 if (!strcmp(display
, "tot"))
2612 c2c
.display
= DISPLAY_TOT
;
2613 else if (!strcmp(display
, "rmt"))
2614 c2c
.display
= DISPLAY_RMT
;
2615 else if (!strcmp(display
, "lcl"))
2616 c2c
.display
= DISPLAY_LCL
;
2618 pr_err("failed: unknown display type: %s\n", str
);
2625 #define for_each_token(__tok, __buf, __sep, __tmp) \
2626 for (__tok = strtok_r(__buf, __sep, &__tmp); __tok; \
2627 __tok = strtok_r(NULL, __sep, &__tmp))
2629 static int build_cl_output(char *cl_sort
, bool no_source
)
2631 char *tok
, *tmp
, *buf
= strdup(cl_sort
);
2632 bool add_pid
= false;
2633 bool add_tid
= false;
2634 bool add_iaddr
= false;
2635 bool add_sym
= false;
2636 bool add_dso
= false;
2637 bool add_src
= false;
2643 for_each_token(tok
, buf
, ",", tmp
) {
2644 if (!strcmp(tok
, "tid")) {
2646 } else if (!strcmp(tok
, "pid")) {
2648 } else if (!strcmp(tok
, "iaddr")) {
2652 add_src
= no_source
? false : true;
2653 } else if (!strcmp(tok
, "dso")) {
2655 } else if (strcmp(tok
, "offset")) {
2656 pr_err("unrecognized sort token: %s\n", tok
);
2662 if (asprintf(&c2c
.cl_output
,
2663 "%s%s%s%s%s%s%s%s%s%s",
2664 c2c
.use_stdio
? "cl_num_empty," : "",
2667 "percent_stores_l1hit,"
2668 "percent_stores_l1miss,"
2669 "offset,offset_node,dcacheline_count,",
2670 add_pid
? "pid," : "",
2671 add_tid
? "tid," : "",
2672 add_iaddr
? "iaddr," : "",
2678 add_sym
? "symbol," : "",
2679 add_dso
? "dso," : "",
2680 add_src
? "cl_srcline," : "",
2686 c2c
.show_src
= add_src
;
2692 static int setup_coalesce(const char *coalesce
, bool no_source
)
2694 const char *c
= coalesce
?: coalesce_default
;
2696 if (asprintf(&c2c
.cl_sort
, "offset,%s", c
) < 0)
2699 if (build_cl_output(c2c
.cl_sort
, no_source
))
2702 if (asprintf(&c2c
.cl_resort
, "offset,%s",
2703 c2c
.display
== DISPLAY_TOT
?
2705 c2c
.display
== DISPLAY_RMT
?
2706 "rmt_hitm,lcl_hitm" :
2707 "lcl_hitm,rmt_hitm") < 0)
2710 pr_debug("coalesce sort fields: %s\n", c2c
.cl_sort
);
2711 pr_debug("coalesce resort fields: %s\n", c2c
.cl_resort
);
2712 pr_debug("coalesce output fields: %s\n", c2c
.cl_output
);
2716 static int perf_c2c__report(int argc
, const char **argv
)
2718 struct perf_session
*session
;
2719 struct ui_progress prog
;
2720 struct perf_data data
= {
2721 .mode
= PERF_DATA_MODE_READ
,
2723 char callchain_default_opt
[] = CALLCHAIN_DEFAULT_OPT
;
2724 const char *display
= NULL
;
2725 const char *coalesce
= NULL
;
2726 bool no_source
= false;
2727 const struct option options
[] = {
2728 OPT_STRING('k', "vmlinux", &symbol_conf
.vmlinux_name
,
2729 "file", "vmlinux pathname"),
2730 OPT_STRING('i', "input", &input_name
, "file",
2731 "the input file to process"),
2732 OPT_INCR('N', "node-info", &c2c
.node_info
,
2733 "show extra node info in report (repeat for more info)"),
2734 #ifdef HAVE_SLANG_SUPPORT
2735 OPT_BOOLEAN(0, "stdio", &c2c
.use_stdio
, "Use the stdio interface"),
2737 OPT_BOOLEAN(0, "stats", &c2c
.stats_only
,
2738 "Display only statistic tables (implies --stdio)"),
2739 OPT_BOOLEAN(0, "full-symbols", &c2c
.symbol_full
,
2740 "Display full length of symbols"),
2741 OPT_BOOLEAN(0, "no-source", &no_source
,
2742 "Do not display Source Line column"),
2743 OPT_BOOLEAN(0, "show-all", &c2c
.show_all
,
2744 "Show all captured HITM lines."),
2745 OPT_CALLBACK_DEFAULT('g', "call-graph", &callchain_param
,
2746 "print_type,threshold[,print_limit],order,sort_key[,branch],value",
2747 callchain_help
, &parse_callchain_opt
,
2748 callchain_default_opt
),
2749 OPT_STRING('d', "display", &display
, "Switch HITM output type", "lcl,rmt"),
2750 OPT_STRING('c', "coalesce", &coalesce
, "coalesce fields",
2751 "coalesce fields: pid,tid,iaddr,dso"),
2752 OPT_BOOLEAN('f', "force", &symbol_conf
.force
, "don't complain, do it"),
2753 OPT_PARENT(c2c_options
),
2758 argc
= parse_options(argc
, argv
, options
, report_c2c_usage
,
2759 PARSE_OPT_STOP_AT_NON_OPTION
);
2761 usage_with_options(report_c2c_usage
, options
);
2764 c2c
.use_stdio
= true;
2766 if (!input_name
|| !strlen(input_name
))
2767 input_name
= "perf.data";
2769 data
.path
= input_name
;
2770 data
.force
= symbol_conf
.force
;
2772 err
= setup_display(display
);
2776 err
= setup_coalesce(coalesce
, no_source
);
2778 pr_debug("Failed to initialize hists\n");
2782 err
= c2c_hists__init(&c2c
.hists
, "dcacheline", 2);
2784 pr_debug("Failed to initialize hists\n");
2788 session
= perf_session__new(&data
, 0, &c2c
.tool
);
2789 if (IS_ERR(session
)) {
2790 err
= PTR_ERR(session
);
2791 pr_debug("Error creating perf session\n");
2795 err
= setup_nodes(session
);
2797 pr_err("Failed setup nodes\n");
2801 err
= mem2node__init(&c2c
.mem2node
, &session
->header
.env
);
2805 err
= setup_callchain(session
->evlist
);
2809 if (symbol__init(&session
->header
.env
) < 0)
2812 /* No pipe support at the moment. */
2813 if (perf_data__is_pipe(session
->data
)) {
2814 pr_debug("No pipe support at the moment.\n");
2823 setup_browser(false);
2825 err
= perf_session__process_events(session
);
2827 pr_err("failed to process sample\n");
2831 c2c_hists__reinit(&c2c
.hists
,
2838 "tot_hitm,lcl_hitm,rmt_hitm,"
2839 "stores,stores_l1hit,stores_l1miss,"
2840 "dram_lcl,dram_rmt,"
2843 "ld_fbhit,ld_l1hit,ld_l2hit,"
2844 "ld_lclhit,ld_rmthit",
2845 c2c
.display
== DISPLAY_TOT
? "tot_hitm" :
2846 c2c
.display
== DISPLAY_LCL
? "lcl_hitm" : "rmt_hitm"
2849 ui_progress__init(&prog
, c2c
.hists
.hists
.nr_entries
, "Sorting...");
2851 hists__collapse_resort(&c2c
.hists
.hists
, NULL
);
2852 hists__output_resort_cb(&c2c
.hists
.hists
, &prog
, resort_hitm_cb
);
2853 hists__iterate_cb(&c2c
.hists
.hists
, resort_cl_cb
);
2855 ui_progress__finish();
2858 pr_err("failed to setup UI\n");
2862 perf_c2c_display(session
);
2865 mem2node__exit(&c2c
.mem2node
);
2867 perf_session__delete(session
);
2872 static int parse_record_events(const struct option
*opt
,
2873 const char *str
, int unset __maybe_unused
)
2875 bool *event_set
= (bool *) opt
->value
;
2878 return perf_mem_events__parse(str
);
2882 static const char * const __usage_record
[] = {
2883 "perf c2c record [<options>] [<command>]",
2884 "perf c2c record [<options>] -- <command> [<options>]",
2888 static const char * const *record_mem_usage
= __usage_record
;
2890 static int perf_c2c__record(int argc
, const char **argv
)
2892 int rec_argc
, i
= 0, j
;
2893 const char **rec_argv
;
2895 bool all_user
= false, all_kernel
= false;
2896 bool event_set
= false;
2897 struct option options
[] = {
2898 OPT_CALLBACK('e', "event", &event_set
, "event",
2899 "event selector. Use 'perf mem record -e list' to list available events",
2900 parse_record_events
),
2901 OPT_BOOLEAN('u', "all-user", &all_user
, "collect only user level data"),
2902 OPT_BOOLEAN('k', "all-kernel", &all_kernel
, "collect only kernel level data"),
2903 OPT_UINTEGER('l', "ldlat", &perf_mem_events__loads_ldlat
, "setup mem-loads latency"),
2904 OPT_PARENT(c2c_options
),
2908 if (perf_mem_events__init()) {
2909 pr_err("failed: memory events not supported\n");
2913 argc
= parse_options(argc
, argv
, options
, record_mem_usage
,
2914 PARSE_OPT_KEEP_UNKNOWN
);
2916 rec_argc
= argc
+ 11; /* max number of arguments */
2917 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
2921 rec_argv
[i
++] = "record";
2924 perf_mem_events
[PERF_MEM_EVENTS__LOAD
].record
= true;
2925 perf_mem_events
[PERF_MEM_EVENTS__STORE
].record
= true;
2928 if (perf_mem_events
[PERF_MEM_EVENTS__LOAD
].record
)
2929 rec_argv
[i
++] = "-W";
2931 rec_argv
[i
++] = "-d";
2932 rec_argv
[i
++] = "--phys-data";
2933 rec_argv
[i
++] = "--sample-cpu";
2935 for (j
= 0; j
< PERF_MEM_EVENTS__MAX
; j
++) {
2936 if (!perf_mem_events
[j
].record
)
2939 if (!perf_mem_events
[j
].supported
) {
2940 pr_err("failed: event '%s' not supported\n",
2941 perf_mem_events
[j
].name
);
2946 rec_argv
[i
++] = "-e";
2947 rec_argv
[i
++] = perf_mem_events__name(j
);
2951 rec_argv
[i
++] = "--all-user";
2954 rec_argv
[i
++] = "--all-kernel";
2956 for (j
= 0; j
< argc
; j
++, i
++)
2957 rec_argv
[i
] = argv
[j
];
2960 pr_debug("calling: ");
2964 while (rec_argv
[j
]) {
2965 pr_debug("%s ", rec_argv
[j
]);
2971 ret
= cmd_record(i
, rec_argv
);
2976 int cmd_c2c(int argc
, const char **argv
)
2978 argc
= parse_options(argc
, argv
, c2c_options
, c2c_usage
,
2979 PARSE_OPT_STOP_AT_NON_OPTION
);
2982 usage_with_options(c2c_usage
, c2c_options
);
2984 if (!strncmp(argv
[0], "rec", 3)) {
2985 return perf_c2c__record(argc
, argv
);
2986 } else if (!strncmp(argv
[0], "rep", 3)) {
2987 return perf_c2c__report(argc
, argv
);
2989 usage_with_options(c2c_usage
, c2c_options
);