Merge tag 'perf-c2c-for-mingo-20161021' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull new 'perf c2c' tool from Arnaldo Carvalho de Melo:

- The 'perf c2c' tool provides means for Shared Data C2C/HITM analysis.

  It allows you to track down cacheline contention. The tool is based
  on x86's load latency and precise store facility events provided by
  Intel CPUs.

  It was tested by Joe Mario and has proven to be useful, finding some
  cacheline contentions. Joe also wrote a blog about c2c tool with
  examples:

    https://joemario.github.io/blog/2016/09/01/c2c-blog/

  Excerpt of the content on this site:

  ---
    At a high level, “perf c2c” will show you:

    * The cachelines where false sharing was detected.
    * The readers and writers to those cachelines, and the offsets where those accesses occurred.
    * The pid, tid, instruction addr, function name, binary object name for those readers and writers.
    * The source file and line number for each reader and writer.
    * The average load latency for the loads to those cachelines.
    * Which numa nodes the samples a cacheline came from and which CPUs were involved.

    Using perf c2c is similar to using the Linux perf tool today.
    First collect data with “perf c2c record” Then generate a report output with “perf c2c report”
  ---

  There one finds extensive details on using the tool, with tips on
  reducing the volume of samples while still capturing enough to do
  its job. (Dick Fowles, Joe Mario, Don Zickus, Jiri Olsa)

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

6 files changed, 169 insertions, 1 deletions

diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index b02992efb513..e1be4132054d 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -1195,6 +1195,7 @@ static void hist_entry__check_and_remove_filter(struct hist_entry *he,
         case HIST_FILTER__GUEST:
         case HIST_FILTER__HOST:
         case HIST_FILTER__SOCKET:
+        case HIST_FILTER__C2C:
         default:
                 return;
         }
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 9928fed8bc59..d4b6514eeef5 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -22,6 +22,7 @@ enum hist_filter {
         HIST_FILTER__GUEST,
         HIST_FILTER__HOST,
         HIST_FILTER__SOCKET,
+        HIST_FILTER__C2C,
 };
 
 enum hist_column {
diff --git a/tools/perf/util/mem-events.c b/tools/perf/util/mem-events.c
index bbc368e7d1e4..e50773286ef6 100644
--- a/tools/perf/util/mem-events.c
+++ b/tools/perf/util/mem-events.c
@@ -9,6 +9,7 @@
 #include "mem-events.h"
 #include "debug.h"
 #include "symbol.h"
+#include "sort.h"
 
 unsigned int perf_mem_events__loads_ldlat = 30;
 
@@ -268,3 +269,130 @@ int perf_script__meminfo_scnprintf(char *out, size_t sz, struct mem_info *mem_in
 
         return i;
 }
+
+int c2c_decode_stats(struct c2c_stats *stats, struct mem_info *mi)
+{
+        union perf_mem_data_src *data_src = &mi->data_src;
+        u64 daddr  = mi->daddr.addr;
+        u64 op     = data_src->mem_op;
+        u64 lvl    = data_src->mem_lvl;
+        u64 snoop  = data_src->mem_snoop;
+        u64 lock   = data_src->mem_lock;
+        int err = 0;
+
+#define P(a, b) PERF_MEM_##a##_##b
+
+        stats->nr_entries++;
+
+        if (lock & P(LOCK, LOCKED)) stats->locks++;
+
+        if (op & P(OP, LOAD)) {
+                /* load */
+                stats->load++;
+
+                if (!daddr) {
+                        stats->ld_noadrs++;
+                        return -1;
+                }
+
+                if (lvl & P(LVL, HIT)) {
+                        if (lvl & P(LVL, UNC)) stats->ld_uncache++;
+                        if (lvl & P(LVL, IO))  stats->ld_io++;
+                        if (lvl & P(LVL, LFB)) stats->ld_fbhit++;
+                        if (lvl & P(LVL, L1 )) stats->ld_l1hit++;
+                        if (lvl & P(LVL, L2 )) stats->ld_l2hit++;
+                        if (lvl & P(LVL, L3 )) {
+                                if (snoop & P(SNOOP, HITM))
+                                        stats->lcl_hitm++;
+                                else
+                                        stats->ld_llchit++;
+                        }
+
+                        if (lvl & P(LVL, LOC_RAM)) {
+                                stats->lcl_dram++;
+                                if (snoop & P(SNOOP, HIT))
+                                        stats->ld_shared++;
+                                else
+                                        stats->ld_excl++;
+                        }
+
+                        if ((lvl & P(LVL, REM_RAM1)) ||
+                            (lvl & P(LVL, REM_RAM2))) {
+                                stats->rmt_dram++;
+                                if (snoop & P(SNOOP, HIT))
+                                        stats->ld_shared++;
+                                else
+                                        stats->ld_excl++;
+                        }
+                }
+
+                if ((lvl & P(LVL, REM_CCE1)) ||
+                    (lvl & P(LVL, REM_CCE2))) {
+                        if (snoop & P(SNOOP, HIT))
+                                stats->rmt_hit++;
+                        else if (snoop & P(SNOOP, HITM))
+                                stats->rmt_hitm++;
+                }
+
+                if ((lvl & P(LVL, MISS)))
+                        stats->ld_miss++;
+
+        } else if (op & P(OP, STORE)) {
+                /* store */
+                stats->store++;
+
+                if (!daddr) {
+                        stats->st_noadrs++;
+                        return -1;
+                }
+
+                if (lvl & P(LVL, HIT)) {
+                        if (lvl & P(LVL, UNC)) stats->st_uncache++;
+                        if (lvl & P(LVL, L1 )) stats->st_l1hit++;
+                }
+                if (lvl & P(LVL, MISS))
+                        if (lvl & P(LVL, L1)) stats->st_l1miss++;
+        } else {
+                /* unparsable data_src? */
+                stats->noparse++;
+                return -1;
+        }
+
+        if (!mi->daddr.map || !mi->iaddr.map) {
+                stats->nomap++;
+                return -1;
+        }
+
+#undef P
+        return err;
+}
+
+void c2c_add_stats(struct c2c_stats *stats, struct c2c_stats *add)
+{
+        stats->nr_entries       += add->nr_entries;
+
+        stats->locks            += add->locks;
+        stats->store            += add->store;
+        stats->st_uncache       += add->st_uncache;
+        stats->st_noadrs        += add->st_noadrs;
+        stats->st_l1hit         += add->st_l1hit;
+        stats->st_l1miss        += add->st_l1miss;
+        stats->load             += add->load;
+        stats->ld_excl          += add->ld_excl;
+        stats->ld_shared        += add->ld_shared;
+        stats->ld_uncache       += add->ld_uncache;
+        stats->ld_io            += add->ld_io;
+        stats->ld_miss          += add->ld_miss;
+        stats->ld_noadrs        += add->ld_noadrs;
+        stats->ld_fbhit         += add->ld_fbhit;
+        stats->ld_l1hit         += add->ld_l1hit;
+        stats->ld_l2hit         += add->ld_l2hit;
+        stats->ld_llchit        += add->ld_llchit;
+        stats->lcl_hitm         += add->lcl_hitm;
+        stats->rmt_hitm         += add->rmt_hitm;
+        stats->rmt_hit          += add->rmt_hit;
+        stats->lcl_dram         += add->lcl_dram;
+        stats->rmt_dram         += add->rmt_dram;
+        stats->nomap            += add->nomap;
+        stats->noparse          += add->noparse;
+}
diff --git a/tools/perf/util/mem-events.h b/tools/perf/util/mem-events.h
index 7f69bf9d789d..faf80403b519 100644
--- a/tools/perf/util/mem-events.h
+++ b/tools/perf/util/mem-events.h
@@ -2,6 +2,10 @@
 #define __PERF_MEM_EVENTS_H
 
 #include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <linux/types.h>
+#include "stat.h"
 
 struct perf_mem_event {
         bool            record;
@@ -33,4 +37,37 @@ int perf_mem__lck_scnprintf(char *out, size_t sz, struct mem_info *mem_info);
 
 int perf_script__meminfo_scnprintf(char *bf, size_t size, struct mem_info *mem_info);
 
+struct c2c_stats {
+        u32     nr_entries;
+
+        u32     locks;               /* count of 'lock' transactions */
+        u32     store;               /* count of all stores in trace */
+        u32     st_uncache;          /* stores to uncacheable address */
+        u32     st_noadrs;           /* cacheable store with no address */
+        u32     st_l1hit;            /* count of stores that hit L1D */
+        u32     st_l1miss;           /* count of stores that miss L1D */
+        u32     load;                /* count of all loads in trace */
+        u32     ld_excl;             /* exclusive loads, rmt/lcl DRAM - snp none/miss */
+        u32     ld_shared;           /* shared loads, rmt/lcl DRAM - snp hit */
+        u32     ld_uncache;          /* loads to uncacheable address */
+        u32     ld_io;               /* loads to io address */
+        u32     ld_miss;             /* loads miss */
+        u32     ld_noadrs;           /* cacheable load with no address */
+        u32     ld_fbhit;            /* count of loads hitting Fill Buffer */
+        u32     ld_l1hit;            /* count of loads that hit L1D */
+        u32     ld_l2hit;            /* count of loads that hit L2D */
+        u32     ld_llchit;           /* count of loads that hit LLC */
+        u32     lcl_hitm;            /* count of loads with local HITM  */
+        u32     rmt_hitm;            /* count of loads with remote HITM */
+        u32     rmt_hit;             /* count of loads with remote hit clean; */
+        u32     lcl_dram;            /* count of loads miss to local DRAM */
+        u32     rmt_dram;            /* count of loads miss to remote DRAM */
+        u32     nomap;               /* count of load/stores with no phys adrs */
+        u32     noparse;             /* count of unparsable data sources */
+};
+
+struct hist_entry;
+int c2c_decode_stats(struct c2c_stats *stats, struct mem_info *mi);
+void c2c_add_stats(struct c2c_stats *stats, struct c2c_stats *add);
+
 #endif /* __PERF_MEM_EVENTS_H */
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 452e15a10dd2..df622f4e301e 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -315,7 +315,7 @@ struct sort_entry sort_sym = {
 
 /* --sort srcline */
 
-static char *hist_entry__get_srcline(struct hist_entry *he)
+char *hist_entry__get_srcline(struct hist_entry *he)
 {
         struct map *map = he->ms.map;
 
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 099c97557d33..7aff317fc7c4 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -280,4 +280,5 @@ int64_t
 sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right);
 int64_t
 sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right);
+char *hist_entry__get_srcline(struct hist_entry *he);
 #endif  /* __PERF_SORT_H */