perf report: Drop cycles 0 for LBR print

For some platforms, for example Broadwell, it doesn't support cycles
for LBR. But the perf always prints cycles:0, it's not necessary.

The patch refactors the LBR info print code and drops the cycles:0.

For example: perf report --branch-history --no-children --stdio

On Broadwell:
--0.91%--__random_r random_r.c:394 (iterations:2)
          __random_r random_r.c:360 (predicted:0.0%)
          __random_r random_r.c:380 (predicted:0.0%)
          __random_r random_r.c:357

On Skylake:
--1.07%--main div.c:39 (predicted:52.4% cycles:1 iterations:17)
          main div.c:44 (predicted:52.4% cycles:1)
          main div.c:42 (cycles:2)
          compute_flag div.c:28 (cycles:2)
          compute_flag div.c:27 (cycles:1)
          rand rand.c:28 (cycles:1)
          rand rand.c:28 (cycles:1)
          __random random.c:298 (cycles:1)
          __random random.c:297 (cycles:1)
          __random random.c:295 (cycles:1)
          __random random.c:295 (cycles:1)
          __random random.c:295 (cycles:1)

Signed-off-by: Yao Jin <yao.jin@linux.intel.com>
	Reviewed-by: Andi Kleen <ak@linux.intel.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Kan Liang <kan.liang@intel.com>
Link: http://lkml.kernel.org/r/1489046786-10061-1-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index d78776a20e8002da76ff0195e243769df2444e49..3cea1fb5404b3ab787c4ad8682c0ece66e975387 100644 (file)
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -1105,63 +1105,100 @@ int callchain_branch_counts(struct callchain_root *root,
                                                  cycles_count);
 }
 
-static int callchain_counts_printf(FILE *fp, char *bf, int bfsize,
-                                  u64 branch_count, u64 predicted_count,
-                                  u64 abort_count, u64 cycles_count,
-                                  u64 iter_count, u64 samples_count)
+static int counts_str_build(char *bf, int bfsize,
+                            u64 branch_count, u64 predicted_count,
+                            u64 abort_count, u64 cycles_count,
+                            u64 iter_count, u64 samples_count)
 {
        double predicted_percent = 0.0;
        const char *null_str = "";
        char iter_str[32];
-       char *str;
-       u64 cycles = 0;
-
-       if (branch_count == 0) {
-               if (fp)
-                       return fprintf(fp, " (calltrace)");
+       char cycle_str[32];
+       char *istr, *cstr;
+       u64 cycles;
 
+       if (branch_count == 0)
                return scnprintf(bf, bfsize, " (calltrace)");
-       }
+
+       cycles = cycles_count / branch_count;
 
        if (iter_count && samples_count) {
-               scnprintf(iter_str, sizeof(iter_str),
-                        ", iterations:%" PRId64 "",
-                        iter_count / samples_count);
-               str = iter_str;
+               if (cycles > 0)
+                       scnprintf(iter_str, sizeof(iter_str),
+                                " iterations:%" PRId64 "",
+                                iter_count / samples_count);
+               else
+                       scnprintf(iter_str, sizeof(iter_str),
+                                "iterations:%" PRId64 "",
+                                iter_count / samples_count);
+               istr = iter_str;
+       } else
+               istr = (char *)null_str;
+
+       if (cycles > 0) {
+               scnprintf(cycle_str, sizeof(cycle_str),
+                         "cycles:%" PRId64 "", cycles);
+               cstr = cycle_str;
        } else
-               str = (char *)null_str;
+               cstr = (char *)null_str;
 
        predicted_percent = predicted_count * 100.0 / branch_count;
-       cycles = cycles_count / branch_count;
 
-       if ((predicted_percent >= 100.0) && (abort_count == 0)) {
-               if (fp)
-                       return fprintf(fp, " (cycles:%" PRId64 "%s)",
-                                      cycles, str);
+       if ((predicted_count == branch_count) && (abort_count == 0)) {
+               if ((cycles > 0) || (istr != (char *)null_str))
+                       return scnprintf(bf, bfsize, " (%s%s)", cstr, istr);
+               else
+                       return scnprintf(bf, bfsize, "%s", (char *)null_str);
+       }
 
-               return scnprintf(bf, bfsize, " (cycles:%" PRId64 "%s)",
-                                cycles, str);
+       if ((predicted_count < branch_count) && (abort_count == 0)) {
+               if ((cycles > 0) || (istr != (char *)null_str))
+                       return scnprintf(bf, bfsize,
+                               " (predicted:%.1f%% %s%s)",
+                               predicted_percent, cstr, istr);
+               else {
+                       return scnprintf(bf, bfsize,
+                               " (predicted:%.1f%%)",
+                               predicted_percent);
+               }
        }
 
-       if ((predicted_percent < 100.0) && (abort_count == 0)) {
-               if (fp)
-                       return fprintf(fp,
-                               " (predicted:%.1f%%, cycles:%" PRId64 "%s)",
-                               predicted_percent, cycles, str);
+       if ((predicted_count == branch_count) && (abort_count > 0)) {
+               if ((cycles > 0) || (istr != (char *)null_str))
+                       return scnprintf(bf, bfsize,
+                               " (abort:%" PRId64 " %s%s)",
+                               abort_count, cstr, istr);
+               else
+                       return scnprintf(bf, bfsize,
+                               " (abort:%" PRId64 ")",
+                               abort_count);
+       }
 
+       if ((cycles > 0) || (istr != (char *)null_str))
                return scnprintf(bf, bfsize,
-                       " (predicted:%.1f%%, cycles:%" PRId64 "%s)",
-                       predicted_percent, cycles, str);
-       }
+                       " (predicted:%.1f%% abort:%" PRId64 " %s%s)",
+                       predicted_percent, abort_count, cstr, istr);
+
+       return scnprintf(bf, bfsize,
+                       " (predicted:%.1f%% abort:%" PRId64 ")",
+                       predicted_percent, abort_count);
+}
+
+static int callchain_counts_printf(FILE *fp, char *bf, int bfsize,
+                                  u64 branch_count, u64 predicted_count,
+                                  u64 abort_count, u64 cycles_count,
+                                  u64 iter_count, u64 samples_count)
+{
+       char str[128];
+
+       counts_str_build(str, sizeof(str), branch_count,
+                        predicted_count, abort_count, cycles_count,
+                        iter_count, samples_count);
 
        if (fp)
-               return fprintf(fp,
-               " (predicted:%.1f%%, abort:%" PRId64 ", cycles:%" PRId64 "%s)",
-                       predicted_percent, abort_count, cycles, str);
+               return fprintf(fp, "%s", str);
 
-       return scnprintf(bf, bfsize,
-               " (predicted:%.1f%%, abort:%" PRId64 ", cycles:%" PRId64 "%s)",
-               predicted_percent, abort_count, cycles, str);
+       return scnprintf(bf, bfsize, "%s", str);
 }
 
 int callchain_list_counts__printf_value(struct callchain_node *node,