From 5b7d8393564a0111698b58989ac74b45cf019701 Mon Sep 17 00:00:00 2001
From: marxin <mliska@suse.cz>
Date: Wed, 9 Nov 2016 14:11:48 +0100
Subject: [PATCH] Dump probability for edges a frequency for BBs
gcc/ChangeLog:
2016-11-11 Martin Liska <mliska@suse.cz>
* gimple-pretty-print.c (dump_edge_probability): New function.
(dump_gimple_switch): Dump label edge probabilities.
(dump_gimple_cond): Likewise.
(dump_gimple_label): Dump
(dump_gimple_bb_header): Dump basic block frequency.
(pp_cfg_jump): Replace e->dest argument with e.
(dump_implicit_edges): Likewise.
* tree-ssa-loop-ivopts.c (get_scaled_computation_cost_at):
Use gimple_bb (at) instead of at->bb.
gcc/testsuite/ChangeLog:
2016-11-11 Martin Liska <mliska@suse.cz>
* gcc.dg/builtin-unreachable-6.c: Update test to not to scan
parts for frequencies/probabilities.
* gcc.dg/pr34027-1.c: Likewise.
* gcc.dg/strict-overflow-2.c: Likewise.
* gcc.dg/tree-ssa/20040703-1.c: Likewise.
* gcc.dg/tree-ssa/builtin-sprintf-2.c: Likewise.
* gcc.dg/tree-ssa/pr32044.c: Likewise.
* gcc.dg/tree-ssa/vector-3.c: Likewise.
* gcc.dg/tree-ssa/vrp101.c: Likewise.
* gcc.dg/tree-ssa/dump-2.c: New test.
---
gcc/gimple-pretty-print.c | 67 ++++++++++++++++++++---
gcc/testsuite/gcc.dg/builtin-unreachable-6.c | 2 +-
gcc/testsuite/gcc.dg/pr34027-1.c | 4 +-
gcc/testsuite/gcc.dg/strict-overflow-2.c | 2 +-
gcc/testsuite/gcc.dg/tree-ssa/20040703-1.c | 2 +-
gcc/testsuite/gcc.dg/tree-ssa/builtin-sprintf-2.c | 4 +-
gcc/testsuite/gcc.dg/tree-ssa/dump-2.c | 9 +++
gcc/testsuite/gcc.dg/tree-ssa/pr32044.c | 4 +-
gcc/testsuite/gcc.dg/tree-ssa/vector-3.c | 2 +-
gcc/testsuite/gcc.dg/tree-ssa/vrp101.c | 2 +-
gcc/tree-ssa-loop-ivopts.c | 2 +-
11 files changed, 80 insertions(+), 20 deletions(-)
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/dump-2.c
@@ -36,6 +36,7 @@ along with GCC; see the file COPYING3. If not see
#include "dumpfile.h" /* for dump_flags */
#include "value-prof.h"
#include "trans-mem.h"
+#include "cfganal.h"
#define INDENT(SPACE) \
do { int i; for (i = 0; i < SPACE; i++) pp_space (buffer); } while (0)
@@ -71,6 +72,14 @@ debug_gimple_stmt (gimple *gs)
print_gimple_stmt (stderr, gs, 0, TDF_VOPS|TDF_MEMSYMS);
}
+/* Dump E probability to BUFFER. */
+
+static void
+dump_edge_probability (pretty_printer *buffer, edge e)
+{
+ pp_scalar (buffer, " [%.1f%%]",
+ e->probability * 100.0 / REG_BR_PROB_BASE);
+}
/* Print GIMPLE statement G to FILE using SPC indentation spaces and
FLAGS as in pp_gimple_stmt_1. */
@@ -902,7 +911,20 @@ dump_gimple_switch (pretty_printer *buffer, gswitch *gs, int spc,
gcc_checking_assert (case_label != NULL_TREE);
dump_generic_node (buffer, case_label, spc, flags, false);
pp_space (buffer);
- dump_generic_node (buffer, CASE_LABEL (case_label), spc, flags, false);
+ tree label = CASE_LABEL (case_label);
+ dump_generic_node (buffer, label, spc, flags, false);
+
+ if (cfun && cfun->cfg)
+ {
+ basic_block dest = label_to_block (label);
+ if (dest)
+ {
+ edge label_edge = find_edge (gimple_bb (gs), dest);
+ if (label_edge)
+ dump_edge_probability (buffer, label_edge);
+ }
+ }
+
if (i < gimple_switch_num_labels (gs) - 1)
pp_string (buffer, ", ");
}
@@ -932,6 +954,23 @@ dump_gimple_cond (pretty_printer *buffer, gcond *gs, int spc, int flags)
dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false);
if (!(flags & TDF_RHS_ONLY))
{
+ edge_iterator ei;
+ edge e, true_edge = NULL, false_edge = NULL;
+ basic_block bb = gimple_bb (gs);
+
+ if (bb)
+ {
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ {
+ if (e->flags & EDGE_TRUE_VALUE)
+ true_edge = e;
+ else if (e->flags & EDGE_FALSE_VALUE)
+ false_edge = e;
+ }
+ }
+
+ bool has_edge_info = true_edge != NULL && false_edge != NULL;
+
pp_right_paren (buffer);
if (gimple_cond_true_label (gs))
@@ -939,6 +978,8 @@ dump_gimple_cond (pretty_printer *buffer, gcond *gs, int spc, int flags)
pp_string (buffer, " goto ");
dump_generic_node (buffer, gimple_cond_true_label (gs),
spc, flags, false);
+ if (has_edge_info)
+ dump_edge_probability (buffer, true_edge);
pp_semicolon (buffer);
}
if (gimple_cond_false_label (gs))
@@ -946,6 +987,9 @@ dump_gimple_cond (pretty_printer *buffer, gcond *gs, int spc, int flags)
pp_string (buffer, " else goto ");
dump_generic_node (buffer, gimple_cond_false_label (gs),
spc, flags, false);
+ if (has_edge_info)
+ dump_edge_probability (buffer, false_edge);
+
pp_semicolon (buffer);
}
}
@@ -966,6 +1010,10 @@ dump_gimple_label (pretty_printer *buffer, glabel *gs, int spc, int flags)
else
{
dump_generic_node (buffer, label, spc, flags, false);
+ basic_block bb = gimple_bb (gs);
+ if (bb)
+ pp_scalar (buffer, " [%.1f%%]",
+ bb->frequency * 100.0 / REG_BR_PROB_BASE);
pp_colon (buffer);
}
if (DECL_NONLOCAL (label))
@@ -2502,7 +2550,8 @@ dump_gimple_bb_header (FILE *outf, basic_block bb, int indent, int flags)
{
gimple *stmt = first_stmt (bb);
if (!stmt || gimple_code (stmt) != GIMPLE_LABEL)
- fprintf (outf, "%*s<bb %d>:\n", indent, "", bb->index);
+ fprintf (outf, "%*s<bb %d> [%.1f%%]:\n", indent, "", bb->index,
+ bb->frequency * 100.0 / REG_BR_PROB_BASE);
}
}
@@ -2546,14 +2595,14 @@ dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
to BUFFER. */
static void
-pp_cfg_jump (pretty_printer *buffer, basic_block bb)
+pp_cfg_jump (pretty_printer *buffer, edge e)
{
gimple *stmt;
- stmt = first_stmt (bb);
+ stmt = first_stmt (e->dest);
pp_string (buffer, "goto <bb ");
- pp_decimal_int (buffer, bb->index);
+ pp_decimal_int (buffer, e->dest->index);
pp_greater (buffer);
if (stmt && gimple_code (stmt) == GIMPLE_LABEL)
{
@@ -2566,6 +2615,8 @@ pp_cfg_jump (pretty_printer *buffer, basic_block bb)
}
else
pp_semicolon (buffer);
+
+ dump_edge_probability (buffer, e);
}
@@ -2593,11 +2644,11 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
INDENT (indent + 2);
- pp_cfg_jump (buffer, true_edge->dest);
+ pp_cfg_jump (buffer, true_edge);
newline_and_indent (buffer, indent);
pp_string (buffer, "else");
newline_and_indent (buffer, indent + 2);
- pp_cfg_jump (buffer, false_edge->dest);
+ pp_cfg_jump (buffer, false_edge);
pp_newline (buffer);
return;
}
@@ -2614,7 +2665,7 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
&& e->goto_locus != UNKNOWN_LOCATION)
dump_location (buffer, e->goto_locus);
- pp_cfg_jump (buffer, e->dest);
+ pp_cfg_jump (buffer, e);
pp_newline (buffer);
}
}
@@ -16,5 +16,5 @@ lab2:
goto *x;
}
-/* { dg-final { scan-tree-dump-times "lab:" 1 "fab1" } } */
+/* { dg-final { scan-tree-dump-times "lab \\\[\[0-9.\]+%\\\]" 1 "fab1" } } */
/* { dg-final { scan-tree-dump-times "__builtin_unreachable" 1 "fab1" } } */
@@ -11,5 +11,5 @@ unsigned long foobar(unsigned long ns)
/* This test was originally introduced to test that we transform
to ns % 10000. See the discussion of PR 32044 why we do not do
that anymore. */
-/* { dg-final { scan-tree-dump-times "%" 0 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "/" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times " % " 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times " / " 0 "optimized" } } */
@@ -12,4 +12,4 @@ foo (int i)
return (i * 100) / 10;
}
-/* { dg-final { scan-tree-dump-not "100" "optimized" } } */
+/* { dg-final { scan-tree-dump-not "\\\* 100" "optimized" } } */
@@ -9,4 +9,4 @@ float foo(float x)
}
/* We should *not* fold the arithmetic. */
-/* { dg-final { scan-tree-dump-times "0\\.0" 0 "dom2"} } */
+/* { dg-final { scan-tree-dump-times "0\\.0\[^%\]" 0 "dom2"} } */
@@ -252,5 +252,5 @@ RNG (0, 6, 8, "%s%ls", "1", L"2");
*/
-/* { dg-final { scan-tree-dump-times ">:\n *__builtin_abort" 114 "optimized" { target { ilp32 || lp64 } } } } */
-/* { dg-final { scan-tree-dump-times ">:\n *__builtin_abort" 83 "optimized" { target { { ! ilp32 } && { ! lp64 } } } } } */
+/* { dg-final { scan-tree-dump-times "> \\\[\[0-9.\]+%\\\]:\n *__builtin_abort" 114 "optimized" { target { ilp32 || lp64 } } } } */
+/* { dg-final { scan-tree-dump-times "> \\\[\[0-9.\]+%\\\]:\n *__builtin_abort" 83 "optimized" { target { { ! ilp32 } && { ! lp64 } } } } } */
new file mode 100644
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-optimized" } */
+
+int f(void)
+{
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump "<bb \[0-9\]> \\\[100\\\.0%\\\]:" "optimized" } } */
@@ -48,6 +48,6 @@ int baz (int n)
/* There should be no division/modulo in the final dump (division and modulo
by 64 are done using bit operations). */
-/* { dg-final { scan-tree-dump-times "/" 0 "optimized" } } */
-/* { dg-final { scan-tree-dump-times "%" 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times " / " 0 "optimized" } } */
+/* { dg-final { scan-tree-dump-times " % " 0 "optimized" } } */
@@ -14,6 +14,6 @@ float f(float b)
/* We should be able to optimize this to just "return 0.0;" */
/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "optimized"} } */
-/* { dg-final { scan-tree-dump-times "0\\\.0" 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times " 0\\\.0" 1 "optimized"} } */
@@ -10,4 +10,4 @@ int main ()
return 0;
}
-/* { dg-final { scan-tree-dump "<bb 2>:\[\n\r \]*return 0;" "optimized" } } */
+/* { dg-final { scan-tree-dump "<bb 2> \\\[\[0-9.\]+%\\\]:\[\n\r \]*return 0;" "optimized" } } */
@@ -4807,7 +4807,7 @@ get_scaled_computation_cost_at (ivopts_data *data, gimple *at, iv_cand *cand,
comp_cost cost)
{
int loop_freq = data->current_loop->header->frequency;
- int bb_freq = at->bb->frequency;
+ int bb_freq = gimple_bb (at)->frequency;
if (loop_freq != 0)
{
gcc_assert (cost.scratch <= cost.cost);
--
2.10.1
Hello. I spent quite time during this stage1 playing with predictors and we found with Honza multiple situations where a prediction was oddly calculated. Thus, we're suggesting to enhance default dump format to show BB frequencies and edge probabilities, as follows: main (int a) { int _1; <bb 2> [100.0%]: if (a_2(D) == 123) goto <bb 5> (<L18>); [18.8%] else goto <bb 3> (sparta); [81.2%] sparta [81.2%]: switch (a_2(D)) <default: <L5> [33.3%], case 1 ... 2: <L18> [66.7%]> <L5> [27.1%]: # _1 = PHI <2(2), 3(4), a_2(D)(3)> <L18> [100.0%]: return _1; } That would exhibit these numbers to people, which would eventually report strange numbers seen in dump files. I was quite surprised that the patch does not break many scanning tests. Patch can bootstrap on ppc64le-redhat-linux and survives regression tests. Thoughts? Martin