]> git.proxmox.com Git - mirror_ubuntu-kernels.git/commitdiff
perf stat: Move shadow stat counters into separate object
authorJiri Olsa <jolsa@kernel.org>
Wed, 3 Jun 2015 14:25:59 +0000 (16:25 +0200)
committerArnaldo Carvalho de Melo <acme@redhat.com>
Mon, 8 Jun 2015 13:30:31 +0000 (10:30 -0300)
Separating shadow counters code into separate object as a cleanup, but
mainly for upcomming changes, so could use it from script command
context.

Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/r/1433341559-31848-10-git-send-email-jolsa@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
tools/perf/builtin-stat.c
tools/perf/util/Build
tools/perf/util/stat-shadow.c [new file with mode: 0644]
tools/perf/util/stat.h

index 50918dc9fb319243ea977c83ad02d415cab5fe5b..ff3d25803400af60a00714b0e37d171cb15dca8d 100644 (file)
@@ -102,13 +102,6 @@ static struct target target = {
        .uid    = UINT_MAX,
 };
 
-enum aggr_mode {
-       AGGR_NONE,
-       AGGR_GLOBAL,
-       AGGR_SOCKET,
-       AGGR_CORE,
-};
-
 static int                     run_count                       =  1;
 static bool                    no_inherit                      = false;
 static bool                    scale                           =  true;
@@ -234,72 +227,6 @@ out_free:
        return -1;
 }
 
-enum {
-       CTX_BIT_USER    = 1 << 0,
-       CTX_BIT_KERNEL  = 1 << 1,
-       CTX_BIT_HV      = 1 << 2,
-       CTX_BIT_HOST    = 1 << 3,
-       CTX_BIT_IDLE    = 1 << 4,
-       CTX_BIT_MAX     = 1 << 5,
-};
-
-#define NUM_CTX CTX_BIT_MAX
-
-static struct stats runtime_nsecs_stats[MAX_NR_CPUS];
-static struct stats runtime_cycles_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_stalled_cycles_front_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_stalled_cycles_back_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_branches_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_cacherefs_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_l1_dcache_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_l1_icache_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_ll_cache_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_itlb_cache_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_dtlb_cache_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_cycles_in_tx_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats walltime_nsecs_stats;
-static struct stats runtime_transaction_stats[NUM_CTX][MAX_NR_CPUS];
-static struct stats runtime_elision_stats[NUM_CTX][MAX_NR_CPUS];
-
-static int evsel_context(struct perf_evsel *evsel)
-{
-       int ctx = 0;
-
-       if (evsel->attr.exclude_kernel)
-               ctx |= CTX_BIT_KERNEL;
-       if (evsel->attr.exclude_user)
-               ctx |= CTX_BIT_USER;
-       if (evsel->attr.exclude_hv)
-               ctx |= CTX_BIT_HV;
-       if (evsel->attr.exclude_host)
-               ctx |= CTX_BIT_HOST;
-       if (evsel->attr.exclude_idle)
-               ctx |= CTX_BIT_IDLE;
-
-       return ctx;
-}
-
-static void reset_shadow_stats(void)
-{
-       memset(runtime_nsecs_stats, 0, sizeof(runtime_nsecs_stats));
-       memset(runtime_cycles_stats, 0, sizeof(runtime_cycles_stats));
-       memset(runtime_stalled_cycles_front_stats, 0, sizeof(runtime_stalled_cycles_front_stats));
-       memset(runtime_stalled_cycles_back_stats, 0, sizeof(runtime_stalled_cycles_back_stats));
-       memset(runtime_branches_stats, 0, sizeof(runtime_branches_stats));
-       memset(runtime_cacherefs_stats, 0, sizeof(runtime_cacherefs_stats));
-       memset(runtime_l1_dcache_stats, 0, sizeof(runtime_l1_dcache_stats));
-       memset(runtime_l1_icache_stats, 0, sizeof(runtime_l1_icache_stats));
-       memset(runtime_ll_cache_stats, 0, sizeof(runtime_ll_cache_stats));
-       memset(runtime_itlb_cache_stats, 0, sizeof(runtime_itlb_cache_stats));
-       memset(runtime_dtlb_cache_stats, 0, sizeof(runtime_dtlb_cache_stats));
-       memset(runtime_cycles_in_tx_stats, 0,
-                       sizeof(runtime_cycles_in_tx_stats));
-       memset(runtime_transaction_stats, 0,
-               sizeof(runtime_transaction_stats));
-       memset(runtime_elision_stats, 0, sizeof(runtime_elision_stats));
-       memset(&walltime_nsecs_stats, 0, sizeof(walltime_nsecs_stats));
-}
-
 static void perf_stat__reset_stats(struct perf_evlist *evlist)
 {
        struct perf_evsel *evsel;
@@ -309,7 +236,7 @@ static void perf_stat__reset_stats(struct perf_evlist *evlist)
                perf_evsel__reset_counts(evsel, perf_evsel__nr_cpus(evsel));
        }
 
-       reset_shadow_stats();
+       perf_stat__reset_shadow_stats();
 }
 
 static int create_perf_stat_counter(struct perf_evsel *evsel)
@@ -346,46 +273,6 @@ static inline int nsec_counter(struct perf_evsel *evsel)
        return 0;
 }
 
-/*
- * Update various tracking values we maintain to print
- * more semantic information such as miss/hit ratios,
- * instruction rates, etc:
- */
-static void update_shadow_stats(struct perf_evsel *counter, u64 *count,
-                               int cpu)
-{
-       int ctx = evsel_context(counter);
-
-       if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
-               update_stats(&runtime_nsecs_stats[cpu], count[0]);
-       else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
-               update_stats(&runtime_cycles_stats[ctx][cpu], count[0]);
-       else if (perf_stat_evsel__is(counter, CYCLES_IN_TX))
-               update_stats(&runtime_transaction_stats[ctx][cpu], count[0]);
-       else if (perf_stat_evsel__is(counter, TRANSACTION_START))
-               update_stats(&runtime_transaction_stats[ctx][cpu], count[0]);
-       else if (perf_stat_evsel__is(counter, ELISION_START))
-               update_stats(&runtime_elision_stats[ctx][cpu], count[0]);
-       else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND))
-               update_stats(&runtime_stalled_cycles_front_stats[ctx][cpu], count[0]);
-       else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND))
-               update_stats(&runtime_stalled_cycles_back_stats[ctx][cpu], count[0]);
-       else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
-               update_stats(&runtime_branches_stats[ctx][cpu], count[0]);
-       else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES))
-               update_stats(&runtime_cacherefs_stats[ctx][cpu], count[0]);
-       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D))
-               update_stats(&runtime_l1_dcache_stats[ctx][cpu], count[0]);
-       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1I))
-               update_stats(&runtime_ll_cache_stats[ctx][cpu], count[0]);
-       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_LL))
-               update_stats(&runtime_ll_cache_stats[ctx][cpu], count[0]);
-       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_DTLB))
-               update_stats(&runtime_dtlb_cache_stats[ctx][cpu], count[0]);
-       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
-               update_stats(&runtime_itlb_cache_stats[ctx][cpu], count[0]);
-}
-
 static void zero_per_pkg(struct perf_evsel *counter)
 {
        if (counter->per_pkg_mask)
@@ -446,7 +333,7 @@ static int read_cb(struct perf_evsel *evsel, int cpu, int thread __maybe_unused,
                perf_counts_values__scale(count, scale, NULL);
                evsel->counts->cpu[cpu] = *count;
                if (aggr_mode == AGGR_NONE)
-                       update_shadow_stats(evsel, count->values, cpu);
+                       perf_stat__update_shadow_stats(evsel, count->values, cpu);
                break;
        case AGGR_GLOBAL:
                aggr->val += count->val;
@@ -494,7 +381,7 @@ static int read_counter_aggr(struct perf_evsel *counter)
        /*
         * Save the full runtime - to allow normalization during printout:
         */
-       update_shadow_stats(counter, count, 0);
+       perf_stat__update_shadow_stats(counter, count, 0);
 
        return 0;
 }
@@ -872,329 +759,6 @@ static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg)
                fprintf(output, "                                   ");
 }
 
-/* used for get_ratio_color() */
-enum grc_type {
-       GRC_STALLED_CYCLES_FE,
-       GRC_STALLED_CYCLES_BE,
-       GRC_CACHE_MISSES,
-       GRC_MAX_NR
-};
-
-static const char *get_ratio_color(enum grc_type type, double ratio)
-{
-       static const double grc_table[GRC_MAX_NR][3] = {
-               [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 },
-               [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 },
-               [GRC_CACHE_MISSES]      = { 20.0, 10.0, 5.0 },
-       };
-       const char *color = PERF_COLOR_NORMAL;
-
-       if (ratio > grc_table[type][0])
-               color = PERF_COLOR_RED;
-       else if (ratio > grc_table[type][1])
-               color = PERF_COLOR_MAGENTA;
-       else if (ratio > grc_table[type][2])
-               color = PERF_COLOR_YELLOW;
-
-       return color;
-}
-
-static void print_stalled_cycles_frontend(FILE *out, int cpu,
-                                         struct perf_evsel *evsel
-                                         __maybe_unused, double avg)
-{
-       double total, ratio = 0.0;
-       const char *color;
-       int ctx = evsel_context(evsel);
-
-       total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
-
-       if (total)
-               ratio = avg / total * 100.0;
-
-       color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio);
-
-       fprintf(out, " #  ");
-       color_fprintf(out, color, "%6.2f%%", ratio);
-       fprintf(out, " frontend cycles idle   ");
-}
-
-static void print_stalled_cycles_backend(FILE *out, int cpu,
-                                        struct perf_evsel *evsel
-                                        __maybe_unused, double avg)
-{
-       double total, ratio = 0.0;
-       const char *color;
-       int ctx = evsel_context(evsel);
-
-       total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
-
-       if (total)
-               ratio = avg / total * 100.0;
-
-       color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio);
-
-       fprintf(out, " #  ");
-       color_fprintf(out, color, "%6.2f%%", ratio);
-       fprintf(out, " backend  cycles idle   ");
-}
-
-static void print_branch_misses(FILE *out, int cpu,
-                               struct perf_evsel *evsel __maybe_unused,
-                               double avg)
-{
-       double total, ratio = 0.0;
-       const char *color;
-       int ctx = evsel_context(evsel);
-
-       total = avg_stats(&runtime_branches_stats[ctx][cpu]);
-
-       if (total)
-               ratio = avg / total * 100.0;
-
-       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-
-       fprintf(out, " #  ");
-       color_fprintf(out, color, "%6.2f%%", ratio);
-       fprintf(out, " of all branches        ");
-}
-
-static void print_l1_dcache_misses(FILE *out, int cpu,
-                                  struct perf_evsel *evsel __maybe_unused,
-                                  double avg)
-{
-       double total, ratio = 0.0;
-       const char *color;
-       int ctx = evsel_context(evsel);
-
-       total = avg_stats(&runtime_l1_dcache_stats[ctx][cpu]);
-
-       if (total)
-               ratio = avg / total * 100.0;
-
-       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-
-       fprintf(out, " #  ");
-       color_fprintf(out, color, "%6.2f%%", ratio);
-       fprintf(out, " of all L1-dcache hits  ");
-}
-
-static void print_l1_icache_misses(FILE *out, int cpu,
-                                  struct perf_evsel *evsel __maybe_unused,
-                                  double avg)
-{
-       double total, ratio = 0.0;
-       const char *color;
-       int ctx = evsel_context(evsel);
-
-       total = avg_stats(&runtime_l1_icache_stats[ctx][cpu]);
-
-       if (total)
-               ratio = avg / total * 100.0;
-
-       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-
-       fprintf(out, " #  ");
-       color_fprintf(out, color, "%6.2f%%", ratio);
-       fprintf(out, " of all L1-icache hits  ");
-}
-
-static void print_dtlb_cache_misses(FILE *out, int cpu,
-                                   struct perf_evsel *evsel __maybe_unused,
-                                   double avg)
-{
-       double total, ratio = 0.0;
-       const char *color;
-       int ctx = evsel_context(evsel);
-
-       total = avg_stats(&runtime_dtlb_cache_stats[ctx][cpu]);
-
-       if (total)
-               ratio = avg / total * 100.0;
-
-       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-
-       fprintf(out, " #  ");
-       color_fprintf(out, color, "%6.2f%%", ratio);
-       fprintf(out, " of all dTLB cache hits ");
-}
-
-static void print_itlb_cache_misses(FILE *out, int cpu,
-                                   struct perf_evsel *evsel __maybe_unused,
-                                   double avg)
-{
-       double total, ratio = 0.0;
-       const char *color;
-       int ctx = evsel_context(evsel);
-
-       total = avg_stats(&runtime_itlb_cache_stats[ctx][cpu]);
-
-       if (total)
-               ratio = avg / total * 100.0;
-
-       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-
-       fprintf(out, " #  ");
-       color_fprintf(out, color, "%6.2f%%", ratio);
-       fprintf(out, " of all iTLB cache hits ");
-}
-
-static void print_ll_cache_misses(FILE *out, int cpu,
-                                 struct perf_evsel *evsel __maybe_unused,
-                                 double avg)
-{
-       double total, ratio = 0.0;
-       const char *color;
-       int ctx = evsel_context(evsel);
-
-       total = avg_stats(&runtime_ll_cache_stats[ctx][cpu]);
-
-       if (total)
-               ratio = avg / total * 100.0;
-
-       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-
-       fprintf(out, " #  ");
-       color_fprintf(out, color, "%6.2f%%", ratio);
-       fprintf(out, " of all LL-cache hits   ");
-}
-
-static void print_shadow_stats(FILE *out, struct perf_evsel *evsel,
-                              double avg, int cpu, enum aggr_mode aggr)
-{
-       double total, ratio = 0.0, total2;
-       int ctx = evsel_context(evsel);
-
-       if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
-               total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
-               if (total) {
-                       ratio = avg / total;
-                       fprintf(out, " #   %5.2f  insns per cycle        ", ratio);
-               } else {
-                       fprintf(out, "                                   ");
-               }
-               total = avg_stats(&runtime_stalled_cycles_front_stats[ctx][cpu]);
-               total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[ctx][cpu]));
-
-               if (total && avg) {
-                       ratio = total / avg;
-                       fprintf(out, "\n");
-                       if (aggr == AGGR_NONE)
-                               fprintf(out, "        ");
-                       fprintf(out, "                                                  #   %5.2f  stalled cycles per insn", ratio);
-               }
-
-       } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
-                       runtime_branches_stats[ctx][cpu].n != 0) {
-               print_branch_misses(out, cpu, evsel, avg);
-       } else if (
-               evsel->attr.type == PERF_TYPE_HW_CACHE &&
-               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1D |
-                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
-                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
-                       runtime_l1_dcache_stats[ctx][cpu].n != 0) {
-               print_l1_dcache_misses(out, cpu, evsel, avg);
-       } else if (
-               evsel->attr.type == PERF_TYPE_HW_CACHE &&
-               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1I |
-                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
-                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
-                       runtime_l1_icache_stats[ctx][cpu].n != 0) {
-               print_l1_icache_misses(out, cpu, evsel, avg);
-       } else if (
-               evsel->attr.type == PERF_TYPE_HW_CACHE &&
-               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_DTLB |
-                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
-                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
-                       runtime_dtlb_cache_stats[ctx][cpu].n != 0) {
-               print_dtlb_cache_misses(out, cpu, evsel, avg);
-       } else if (
-               evsel->attr.type == PERF_TYPE_HW_CACHE &&
-               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_ITLB |
-                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
-                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
-                       runtime_itlb_cache_stats[ctx][cpu].n != 0) {
-               print_itlb_cache_misses(out, cpu, evsel, avg);
-       } else if (
-               evsel->attr.type == PERF_TYPE_HW_CACHE &&
-               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_LL |
-                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
-                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
-                       runtime_ll_cache_stats[ctx][cpu].n != 0) {
-               print_ll_cache_misses(out, cpu, evsel, avg);
-       } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) &&
-                       runtime_cacherefs_stats[ctx][cpu].n != 0) {
-               total = avg_stats(&runtime_cacherefs_stats[ctx][cpu]);
-
-               if (total)
-                       ratio = avg * 100 / total;
-
-               fprintf(out, " # %8.3f %% of all cache refs    ", ratio);
-
-       } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
-               print_stalled_cycles_frontend(out, cpu, evsel, avg);
-       } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) {
-               print_stalled_cycles_backend(out, cpu, evsel, avg);
-       } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
-               total = avg_stats(&runtime_nsecs_stats[cpu]);
-
-               if (total) {
-                       ratio = avg / total;
-                       fprintf(out, " # %8.3f GHz                    ", ratio);
-               } else {
-                       fprintf(out, "                                   ");
-               }
-       } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX)) {
-               total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
-               if (total)
-                       fprintf(out,
-                               " #   %5.2f%% transactional cycles   ",
-                               100.0 * (avg / total));
-       } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX_CP)) {
-               total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
-               total2 = avg_stats(&runtime_cycles_in_tx_stats[ctx][cpu]);
-               if (total2 < avg)
-                       total2 = avg;
-               if (total)
-                       fprintf(out,
-                               " #   %5.2f%% aborted cycles         ",
-                               100.0 * ((total2-avg) / total));
-       } else if (perf_stat_evsel__is(evsel, TRANSACTION_START) &&
-                  avg > 0 &&
-                  runtime_cycles_in_tx_stats[ctx][cpu].n != 0) {
-               total = avg_stats(&runtime_cycles_in_tx_stats[ctx][cpu]);
-
-               if (total)
-                       ratio = total / avg;
-
-               fprintf(out, " # %8.0f cycles / transaction   ", ratio);
-       } else if (perf_stat_evsel__is(evsel, ELISION_START) &&
-                  avg > 0 &&
-                  runtime_cycles_in_tx_stats[ctx][cpu].n != 0) {
-               total = avg_stats(&runtime_cycles_in_tx_stats[ctx][cpu]);
-
-               if (total)
-                       ratio = total / avg;
-
-               fprintf(out, " # %8.0f cycles / elision       ", ratio);
-       } else if (runtime_nsecs_stats[cpu].n != 0) {
-               char unit = 'M';
-
-               total = avg_stats(&runtime_nsecs_stats[cpu]);
-
-               if (total)
-                       ratio = 1000.0 * avg / total;
-               if (ratio < 0.001) {
-                       ratio *= 1000;
-                       unit = 'K';
-               }
-
-               fprintf(out, " # %8.3f %c/sec                  ", ratio, unit);
-       } else {
-               fprintf(out, "                                   ");
-       }
-}
-
 static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
 {
        double sc =  evsel->scale;
@@ -1230,7 +794,7 @@ static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
        if (csv_output || interval)
                return;
 
-       print_shadow_stats(output, evsel, avg, cpu, aggr_mode);
+       perf_stat__print_shadow_stats(output, evsel, avg, cpu, aggr_mode);
 }
 
 static void print_aggr(char *prefix)
index e4b676de2f64351e4d72a72bf0289f8a1591f6f7..586a59d46022a9fc8901807f5c02be4e2551db25 100644 (file)
@@ -68,6 +68,7 @@ libperf-y += rblist.o
 libperf-y += intlist.o
 libperf-y += vdso.o
 libperf-y += stat.o
+libperf-y += stat-shadow.o
 libperf-y += record.o
 libperf-y += srcline.o
 libperf-y += data.o
diff --git a/tools/perf/util/stat-shadow.c b/tools/perf/util/stat-shadow.c
new file mode 100644 (file)
index 0000000..53e8bb7
--- /dev/null
@@ -0,0 +1,434 @@
+#include <stdio.h>
+#include "evsel.h"
+#include "stat.h"
+#include "color.h"
+
+enum {
+       CTX_BIT_USER    = 1 << 0,
+       CTX_BIT_KERNEL  = 1 << 1,
+       CTX_BIT_HV      = 1 << 2,
+       CTX_BIT_HOST    = 1 << 3,
+       CTX_BIT_IDLE    = 1 << 4,
+       CTX_BIT_MAX     = 1 << 5,
+};
+
+#define NUM_CTX CTX_BIT_MAX
+
+static struct stats runtime_nsecs_stats[MAX_NR_CPUS];
+static struct stats runtime_cycles_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_stalled_cycles_front_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_stalled_cycles_back_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_branches_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_cacherefs_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_l1_dcache_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_l1_icache_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_ll_cache_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_itlb_cache_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_dtlb_cache_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_cycles_in_tx_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_transaction_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_elision_stats[NUM_CTX][MAX_NR_CPUS];
+
+struct stats walltime_nsecs_stats;
+
+static int evsel_context(struct perf_evsel *evsel)
+{
+       int ctx = 0;
+
+       if (evsel->attr.exclude_kernel)
+               ctx |= CTX_BIT_KERNEL;
+       if (evsel->attr.exclude_user)
+               ctx |= CTX_BIT_USER;
+       if (evsel->attr.exclude_hv)
+               ctx |= CTX_BIT_HV;
+       if (evsel->attr.exclude_host)
+               ctx |= CTX_BIT_HOST;
+       if (evsel->attr.exclude_idle)
+               ctx |= CTX_BIT_IDLE;
+
+       return ctx;
+}
+
+void perf_stat__reset_shadow_stats(void)
+{
+       memset(runtime_nsecs_stats, 0, sizeof(runtime_nsecs_stats));
+       memset(runtime_cycles_stats, 0, sizeof(runtime_cycles_stats));
+       memset(runtime_stalled_cycles_front_stats, 0, sizeof(runtime_stalled_cycles_front_stats));
+       memset(runtime_stalled_cycles_back_stats, 0, sizeof(runtime_stalled_cycles_back_stats));
+       memset(runtime_branches_stats, 0, sizeof(runtime_branches_stats));
+       memset(runtime_cacherefs_stats, 0, sizeof(runtime_cacherefs_stats));
+       memset(runtime_l1_dcache_stats, 0, sizeof(runtime_l1_dcache_stats));
+       memset(runtime_l1_icache_stats, 0, sizeof(runtime_l1_icache_stats));
+       memset(runtime_ll_cache_stats, 0, sizeof(runtime_ll_cache_stats));
+       memset(runtime_itlb_cache_stats, 0, sizeof(runtime_itlb_cache_stats));
+       memset(runtime_dtlb_cache_stats, 0, sizeof(runtime_dtlb_cache_stats));
+       memset(runtime_cycles_in_tx_stats, 0,
+                       sizeof(runtime_cycles_in_tx_stats));
+       memset(runtime_transaction_stats, 0,
+               sizeof(runtime_transaction_stats));
+       memset(runtime_elision_stats, 0, sizeof(runtime_elision_stats));
+       memset(&walltime_nsecs_stats, 0, sizeof(walltime_nsecs_stats));
+}
+
+/*
+ * Update various tracking values we maintain to print
+ * more semantic information such as miss/hit ratios,
+ * instruction rates, etc:
+ */
+void perf_stat__update_shadow_stats(struct perf_evsel *counter, u64 *count,
+                                   int cpu)
+{
+       int ctx = evsel_context(counter);
+
+       if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
+               update_stats(&runtime_nsecs_stats[cpu], count[0]);
+       else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
+               update_stats(&runtime_cycles_stats[ctx][cpu], count[0]);
+       else if (perf_stat_evsel__is(counter, CYCLES_IN_TX))
+               update_stats(&runtime_transaction_stats[ctx][cpu], count[0]);
+       else if (perf_stat_evsel__is(counter, TRANSACTION_START))
+               update_stats(&runtime_transaction_stats[ctx][cpu], count[0]);
+       else if (perf_stat_evsel__is(counter, ELISION_START))
+               update_stats(&runtime_elision_stats[ctx][cpu], count[0]);
+       else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND))
+               update_stats(&runtime_stalled_cycles_front_stats[ctx][cpu], count[0]);
+       else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND))
+               update_stats(&runtime_stalled_cycles_back_stats[ctx][cpu], count[0]);
+       else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
+               update_stats(&runtime_branches_stats[ctx][cpu], count[0]);
+       else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES))
+               update_stats(&runtime_cacherefs_stats[ctx][cpu], count[0]);
+       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D))
+               update_stats(&runtime_l1_dcache_stats[ctx][cpu], count[0]);
+       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1I))
+               update_stats(&runtime_ll_cache_stats[ctx][cpu], count[0]);
+       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_LL))
+               update_stats(&runtime_ll_cache_stats[ctx][cpu], count[0]);
+       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_DTLB))
+               update_stats(&runtime_dtlb_cache_stats[ctx][cpu], count[0]);
+       else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
+               update_stats(&runtime_itlb_cache_stats[ctx][cpu], count[0]);
+}
+
+/* used for get_ratio_color() */
+enum grc_type {
+       GRC_STALLED_CYCLES_FE,
+       GRC_STALLED_CYCLES_BE,
+       GRC_CACHE_MISSES,
+       GRC_MAX_NR
+};
+
+static const char *get_ratio_color(enum grc_type type, double ratio)
+{
+       static const double grc_table[GRC_MAX_NR][3] = {
+               [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 },
+               [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 },
+               [GRC_CACHE_MISSES]      = { 20.0, 10.0, 5.0 },
+       };
+       const char *color = PERF_COLOR_NORMAL;
+
+       if (ratio > grc_table[type][0])
+               color = PERF_COLOR_RED;
+       else if (ratio > grc_table[type][1])
+               color = PERF_COLOR_MAGENTA;
+       else if (ratio > grc_table[type][2])
+               color = PERF_COLOR_YELLOW;
+
+       return color;
+}
+
+static void print_stalled_cycles_frontend(FILE *out, int cpu,
+                                         struct perf_evsel *evsel
+                                         __maybe_unused, double avg)
+{
+       double total, ratio = 0.0;
+       const char *color;
+       int ctx = evsel_context(evsel);
+
+       total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
+
+       if (total)
+               ratio = avg / total * 100.0;
+
+       color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio);
+
+       fprintf(out, " #  ");
+       color_fprintf(out, color, "%6.2f%%", ratio);
+       fprintf(out, " frontend cycles idle   ");
+}
+
+static void print_stalled_cycles_backend(FILE *out, int cpu,
+                                        struct perf_evsel *evsel
+                                        __maybe_unused, double avg)
+{
+       double total, ratio = 0.0;
+       const char *color;
+       int ctx = evsel_context(evsel);
+
+       total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
+
+       if (total)
+               ratio = avg / total * 100.0;
+
+       color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio);
+
+       fprintf(out, " #  ");
+       color_fprintf(out, color, "%6.2f%%", ratio);
+       fprintf(out, " backend  cycles idle   ");
+}
+
+static void print_branch_misses(FILE *out, int cpu,
+                               struct perf_evsel *evsel __maybe_unused,
+                               double avg)
+{
+       double total, ratio = 0.0;
+       const char *color;
+       int ctx = evsel_context(evsel);
+
+       total = avg_stats(&runtime_branches_stats[ctx][cpu]);
+
+       if (total)
+               ratio = avg / total * 100.0;
+
+       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
+
+       fprintf(out, " #  ");
+       color_fprintf(out, color, "%6.2f%%", ratio);
+       fprintf(out, " of all branches        ");
+}
+
+static void print_l1_dcache_misses(FILE *out, int cpu,
+                                  struct perf_evsel *evsel __maybe_unused,
+                                  double avg)
+{
+       double total, ratio = 0.0;
+       const char *color;
+       int ctx = evsel_context(evsel);
+
+       total = avg_stats(&runtime_l1_dcache_stats[ctx][cpu]);
+
+       if (total)
+               ratio = avg / total * 100.0;
+
+       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
+
+       fprintf(out, " #  ");
+       color_fprintf(out, color, "%6.2f%%", ratio);
+       fprintf(out, " of all L1-dcache hits  ");
+}
+
+static void print_l1_icache_misses(FILE *out, int cpu,
+                                  struct perf_evsel *evsel __maybe_unused,
+                                  double avg)
+{
+       double total, ratio = 0.0;
+       const char *color;
+       int ctx = evsel_context(evsel);
+
+       total = avg_stats(&runtime_l1_icache_stats[ctx][cpu]);
+
+       if (total)
+               ratio = avg / total * 100.0;
+
+       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
+
+       fprintf(out, " #  ");
+       color_fprintf(out, color, "%6.2f%%", ratio);
+       fprintf(out, " of all L1-icache hits  ");
+}
+
+static void print_dtlb_cache_misses(FILE *out, int cpu,
+                                   struct perf_evsel *evsel __maybe_unused,
+                                   double avg)
+{
+       double total, ratio = 0.0;
+       const char *color;
+       int ctx = evsel_context(evsel);
+
+       total = avg_stats(&runtime_dtlb_cache_stats[ctx][cpu]);
+
+       if (total)
+               ratio = avg / total * 100.0;
+
+       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
+
+       fprintf(out, " #  ");
+       color_fprintf(out, color, "%6.2f%%", ratio);
+       fprintf(out, " of all dTLB cache hits ");
+}
+
+static void print_itlb_cache_misses(FILE *out, int cpu,
+                                   struct perf_evsel *evsel __maybe_unused,
+                                   double avg)
+{
+       double total, ratio = 0.0;
+       const char *color;
+       int ctx = evsel_context(evsel);
+
+       total = avg_stats(&runtime_itlb_cache_stats[ctx][cpu]);
+
+       if (total)
+               ratio = avg / total * 100.0;
+
+       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
+
+       fprintf(out, " #  ");
+       color_fprintf(out, color, "%6.2f%%", ratio);
+       fprintf(out, " of all iTLB cache hits ");
+}
+
+static void print_ll_cache_misses(FILE *out, int cpu,
+                                 struct perf_evsel *evsel __maybe_unused,
+                                 double avg)
+{
+       double total, ratio = 0.0;
+       const char *color;
+       int ctx = evsel_context(evsel);
+
+       total = avg_stats(&runtime_ll_cache_stats[ctx][cpu]);
+
+       if (total)
+               ratio = avg / total * 100.0;
+
+       color = get_ratio_color(GRC_CACHE_MISSES, ratio);
+
+       fprintf(out, " #  ");
+       color_fprintf(out, color, "%6.2f%%", ratio);
+       fprintf(out, " of all LL-cache hits   ");
+}
+
+void perf_stat__print_shadow_stats(FILE *out, struct perf_evsel *evsel,
+                                  double avg, int cpu, enum aggr_mode aggr)
+{
+       double total, ratio = 0.0, total2;
+       int ctx = evsel_context(evsel);
+
+       if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
+               total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
+               if (total) {
+                       ratio = avg / total;
+                       fprintf(out, " #   %5.2f  insns per cycle        ", ratio);
+               } else {
+                       fprintf(out, "                                   ");
+               }
+               total = avg_stats(&runtime_stalled_cycles_front_stats[ctx][cpu]);
+               total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[ctx][cpu]));
+
+               if (total && avg) {
+                       ratio = total / avg;
+                       fprintf(out, "\n");
+                       if (aggr == AGGR_NONE)
+                               fprintf(out, "        ");
+                       fprintf(out, "                                                  #   %5.2f  stalled cycles per insn", ratio);
+               }
+
+       } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
+                       runtime_branches_stats[ctx][cpu].n != 0) {
+               print_branch_misses(out, cpu, evsel, avg);
+       } else if (
+               evsel->attr.type == PERF_TYPE_HW_CACHE &&
+               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1D |
+                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
+                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
+                       runtime_l1_dcache_stats[ctx][cpu].n != 0) {
+               print_l1_dcache_misses(out, cpu, evsel, avg);
+       } else if (
+               evsel->attr.type == PERF_TYPE_HW_CACHE &&
+               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1I |
+                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
+                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
+                       runtime_l1_icache_stats[ctx][cpu].n != 0) {
+               print_l1_icache_misses(out, cpu, evsel, avg);
+       } else if (
+               evsel->attr.type == PERF_TYPE_HW_CACHE &&
+               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_DTLB |
+                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
+                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
+                       runtime_dtlb_cache_stats[ctx][cpu].n != 0) {
+               print_dtlb_cache_misses(out, cpu, evsel, avg);
+       } else if (
+               evsel->attr.type == PERF_TYPE_HW_CACHE &&
+               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_ITLB |
+                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
+                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
+                       runtime_itlb_cache_stats[ctx][cpu].n != 0) {
+               print_itlb_cache_misses(out, cpu, evsel, avg);
+       } else if (
+               evsel->attr.type == PERF_TYPE_HW_CACHE &&
+               evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_LL |
+                                       ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
+                                       ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
+                       runtime_ll_cache_stats[ctx][cpu].n != 0) {
+               print_ll_cache_misses(out, cpu, evsel, avg);
+       } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) &&
+                       runtime_cacherefs_stats[ctx][cpu].n != 0) {
+               total = avg_stats(&runtime_cacherefs_stats[ctx][cpu]);
+
+               if (total)
+                       ratio = avg * 100 / total;
+
+               fprintf(out, " # %8.3f %% of all cache refs    ", ratio);
+
+       } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
+               print_stalled_cycles_frontend(out, cpu, evsel, avg);
+       } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) {
+               print_stalled_cycles_backend(out, cpu, evsel, avg);
+       } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
+               total = avg_stats(&runtime_nsecs_stats[cpu]);
+
+               if (total) {
+                       ratio = avg / total;
+                       fprintf(out, " # %8.3f GHz                    ", ratio);
+               } else {
+                       fprintf(out, "                                   ");
+               }
+       } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX)) {
+               total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
+               if (total)
+                       fprintf(out,
+                               " #   %5.2f%% transactional cycles   ",
+                               100.0 * (avg / total));
+       } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX_CP)) {
+               total = avg_stats(&runtime_cycles_stats[ctx][cpu]);
+               total2 = avg_stats(&runtime_cycles_in_tx_stats[ctx][cpu]);
+               if (total2 < avg)
+                       total2 = avg;
+               if (total)
+                       fprintf(out,
+                               " #   %5.2f%% aborted cycles         ",
+                               100.0 * ((total2-avg) / total));
+       } else if (perf_stat_evsel__is(evsel, TRANSACTION_START) &&
+                  avg > 0 &&
+                  runtime_cycles_in_tx_stats[ctx][cpu].n != 0) {
+               total = avg_stats(&runtime_cycles_in_tx_stats[ctx][cpu]);
+
+               if (total)
+                       ratio = total / avg;
+
+               fprintf(out, " # %8.0f cycles / transaction   ", ratio);
+       } else if (perf_stat_evsel__is(evsel, ELISION_START) &&
+                  avg > 0 &&
+                  runtime_cycles_in_tx_stats[ctx][cpu].n != 0) {
+               total = avg_stats(&runtime_cycles_in_tx_stats[ctx][cpu]);
+
+               if (total)
+                       ratio = total / avg;
+
+               fprintf(out, " # %8.0f cycles / elision       ", ratio);
+       } else if (runtime_nsecs_stats[cpu].n != 0) {
+               char unit = 'M';
+
+               total = avg_stats(&runtime_nsecs_stats[cpu]);
+
+               if (total)
+                       ratio = 1000.0 * avg / total;
+               if (ratio < 0.001) {
+                       ratio *= 1000;
+                       unit = 'K';
+               }
+
+               fprintf(out, " # %8.3f %c/sec                  ", ratio, unit);
+       } else {
+               fprintf(out, "                                   ");
+       }
+}
index 3df529bd077432858149130eefae1c99e9098115..615c779eb42ac708d94a13556d3dc511bf94e24d 100644 (file)
@@ -2,6 +2,7 @@
 #define __PERF_STATS_H
 
 #include <linux/types.h>
+#include <stdio.h>
 
 struct stats
 {
@@ -23,6 +24,13 @@ struct perf_stat {
        enum perf_stat_evsel_id id;
 };
 
+enum aggr_mode {
+       AGGR_NONE,
+       AGGR_GLOBAL,
+       AGGR_SOCKET,
+       AGGR_CORE,
+};
+
 void update_stats(struct stats *stats, u64 val);
 double avg_stats(struct stats *stats);
 double stddev_stats(struct stats *stats);
@@ -46,4 +54,12 @@ bool __perf_evsel_stat__is(struct perf_evsel *evsel,
 
 void perf_stat_evsel_id_init(struct perf_evsel *evsel);
 
+extern struct stats walltime_nsecs_stats;
+
+void perf_stat__reset_shadow_stats(void);
+void perf_stat__update_shadow_stats(struct perf_evsel *counter, u64 *count,
+                                   int cpu);
+void perf_stat__print_shadow_stats(FILE *out, struct perf_evsel *evsel,
+                                  double avg, int cpu, enum aggr_mode aggr);
+
 #endif