Skip to content

R
riscv-gcc-1
Commit 4adaad64 by Jan Hubicka Committed by Jan Hubicka
Options

re PR tree-optimization/79224 (Large C-Ray slowdown) 


	PR ipa/79224
	* ipa-inline-analysis.c (dump_predicate): Add optional parameter NL.
	(account_size_time): Use two predicates - exec_pred and
	nonconst_pred_ptr.
	(evaluate_conditions_for_known_args): Compute both clause and
	nonspec_clause.
	(evaluate_properties_for_edge): Evaulate both clause and nonspec_clause.
	(inline_summary_t::duplicate): Update.
	(estimate_function_body_sizes): Caluculate exec and nonconst predicates
	separately.
	(compute_inline_parameters): Likewise.
	(estimate_edge_size_and_time): Update caluclation of time.
	(estimate_node_size_and_time): Compute both time and nonspecialized
	time.
	(estimate_ipcp_clone_size_and_time): Update.
	(inline_merge_summary): Update.
	(do_estimate_edge_time): Update.
	(do_estimate_edge_size): Update.
	(do_estimate_edge_hints): Update.
	(inline_read_section, inline_write_summary): Stream both new predicates.
	* ipa-inline.c (compute_uninlined_call_time): Take uninlined_call_time
	as argument.
	(compute_inlined_call_time): Cleanup.
	(big_speedup_p): Update.
	(edge_badness): Update.
	* ipa-inline.h (INLINE_TIME_SCALE): Remove.
	(size_time_entry): Replace predicate by exec_predicate and
	nonconst_predicate.
	(edge_growth_cache_entry): Cache both time nad nonspecialized time.
	(estimate_edge_time): Return also nonspec_time.
	(reset_edge_growth_cache): Update.

From-SVN: r247417
parent 8cbe7981
Showing with 304 additions and 143 deletions
gcc/ChangeLog
2017-04-29 Jan Hubicka <hubicka@ucw.cz>
PR ipa/79224
* ipa-inline-analysis.c (dump_predicate): Add optional parameter NL.
(account_size_time): Use two predicates - exec_pred and
nonconst_pred_ptr.
(evaluate_conditions_for_known_args): Compute both clause and
nonspec_clause.
(evaluate_properties_for_edge): Evaulate both clause and nonspec_clause.
(inline_summary_t::duplicate): Update.
(estimate_function_body_sizes): Caluculate exec and nonconst predicates
separately.
(compute_inline_parameters): Likewise.
(estimate_edge_size_and_time): Update caluclation of time.
(estimate_node_size_and_time): Compute both time and nonspecialized
time.
(estimate_ipcp_clone_size_and_time): Update.
(inline_merge_summary): Update.
(do_estimate_edge_time): Update.
(do_estimate_edge_size): Update.
(do_estimate_edge_hints): Update.
(inline_read_section, inline_write_summary): Stream both new predicates.
* ipa-inline.c (compute_uninlined_call_time): Take uninlined_call_time
as argument.
(compute_inlined_call_time): Cleanup.
(big_speedup_p): Update.
(edge_badness): Update.
* ipa-inline.h (INLINE_TIME_SCALE): Remove.
(size_time_entry): Replace predicate by exec_predicate and
nonconst_predicate.
(edge_growth_cache_entry): Cache both time nad nonspecialized time.
(estimate_edge_time): Return also nonspec_time.
(reset_edge_growth_cache): Update.
2017-04-29 Jakub Jelinek <jakub@redhat.com>
PR rtl-optimization/80491
......
gcc/ipa-inline-analysis.c
......@@ -585,10 +585,12 @@ dump_clause (FILE *f, conditions conds, clause_t clause)
}
/* Dump predicate PREDICATE. */
/* Dump PREDICATE to F. CONDS a vector of conditions used when evauating
predicats. When NL is true new line is output at the end of dump. */
static void
dump_predicate (FILE *f, conditions conds, struct predicate *pred)
dump_predicate (FILE *f, conditions conds, struct predicate *pred,
bool nl = true)
{
int i;
if (true_predicate_p (pred))
......@@ -600,7 +602,8 @@ dump_predicate (FILE *f, conditions conds, struct predicate *pred)
fprintf (f, " && ");
dump_clause (f, conds, pred->clause[i]);
}
fprintf (f, "\n");
if (nl)
fprintf (f, "\n");
}
......@@ -660,17 +663,27 @@ dump_inline_hints (FILE *f, inline_hints hints)
}
/* Record SIZE and TIME under condition PRED into the inline summary. */
/* Record SIZE and TIME to SUMMARY.
The accounted code will be executed when EXEC_PRED is true.
When NONCONST_PRED is false the code will evaulate to constant and
will get optimized out in specialized clones of the function. */
static void
account_size_time (struct inline_summary *summary, int size, sreal time,
struct predicate *pred)
struct predicate *exec_pred,
struct predicate *nonconst_pred_ptr)
{
size_time_entry *e;
bool found = false;
int i;
struct predicate nonconst_pred;
if (false_predicate_p (pred))
if (false_predicate_p (exec_pred))
return;
nonconst_pred = and_predicates (summary->conds, nonconst_pred_ptr, exec_pred);
if (false_predicate_p (&nonconst_pred))
return;
/* We need to create initial empty unconitional clause, but otherwie
......@@ -681,7 +694,8 @@ account_size_time (struct inline_summary *summary, int size, sreal time,
gcc_assert (time >= 0);
for (i = 0; vec_safe_iterate (summary->entry, i, &e); i++)
if (predicates_equal_p (&e->predicate, pred))
if (predicates_equal_p (&e->exec_predicate, exec_pred)
&& predicates_equal_p (&e->nonconst_predicate, &nonconst_pred))
{
found = true;
break;
......@@ -691,7 +705,7 @@ account_size_time (struct inline_summary *summary, int size, sreal time,
i = 0;
found = true;
e = &(*summary->entry)[0];
gcc_assert (!e->predicate.clause[0]);
gcc_assert (!e->exec_predicate.clause[0]);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
"\t\tReached limit on number of entries, "
......@@ -700,17 +714,25 @@ account_size_time (struct inline_summary *summary, int size, sreal time,
if (dump_file && (dump_flags & TDF_DETAILS) && (time != 0 || size))
{
fprintf (dump_file,
"\t\tAccounting size:%3.2f, time:%3.2f on %spredicate:",
"\t\tAccounting size:%3.2f, time:%3.2f on %spredicate exec:",
((double) size) / INLINE_SIZE_SCALE,
(time.to_double ()) / INLINE_TIME_SCALE, found ? "" : "new ");
dump_predicate (dump_file, summary->conds, pred);
(time.to_double ()), found ? "" : "new ");
dump_predicate (dump_file, summary->conds, exec_pred, 0);
if (!predicates_equal_p (exec_pred, &nonconst_pred))
{
fprintf (dump_file, " nonconst:");
dump_predicate (dump_file, summary->conds, &nonconst_pred);
}
else
fprintf (dump_file, "\n");
}
if (!found)
{
struct size_time_entry new_entry;
new_entry.size = size;
new_entry.time = time;
new_entry.predicate = *pred;
new_entry.exec_predicate = *exec_pred;
new_entry.nonconst_predicate = nonconst_pred;
vec_safe_push (summary->entry, new_entry);
}
else
......@@ -795,21 +817,33 @@ set_hint_predicate (struct predicate **p, struct predicate new_predicate)
}
/* KNOWN_VALS is partial mapping of parameters of NODE to constant values.
/* Compute what conditions may or may not hold given invormation about
parameters. RET_CLAUSE returns truths that may hold in a specialized copy,
whie RET_NONSPEC_CLAUSE returns truths that may hold in an nonspecialized
copy when called in a given context. It is a bitmask of conditions. Bit
0 means that condition is known to be false, while bit 1 means that condition
may or may not be true. These differs - for example NOT_INLINED condition
is always false in the second and also builtin_constant_p tests can not use
the fact that parameter is indeed a constant.
KNOWN_VALS is partial mapping of parameters of NODE to constant values.
KNOWN_AGGS is a vector of aggreggate jump functions for each parameter.
Return clause of possible truths. When INLINE_P is true, assume that we are
inlining.
ERROR_MARK means compile time invariant. */
static clause_t
static void
evaluate_conditions_for_known_args (struct cgraph_node *node,
bool inline_p,
vec<tree> known_vals,
vec<ipa_agg_jump_function_p>
known_aggs)
known_aggs,
clause_t *ret_clause,
clause_t *ret_nonspec_clause)
{
clause_t clause = inline_p ? 0 : 1 << predicate_not_inlined_condition;
clause_t nonspec_clause = 1 << predicate_not_inlined_condition;
struct inline_summary *info = inline_summaries->get (node);
int i;
struct condition *c;
......@@ -828,6 +862,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
if (c->operand_num >= (int) known_vals.length ())
{
clause |= 1 << (i + predicate_first_dynamic_condition);
nonspec_clause |= 1 << (i + predicate_first_dynamic_condition);
continue;
}
......@@ -859,18 +894,26 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
if (!val)
{
clause |= 1 << (i + predicate_first_dynamic_condition);
nonspec_clause |= 1 << (i + predicate_first_dynamic_condition);
continue;
}
if (c->code == CHANGED)
continue;
{
nonspec_clause |= 1 << (i + predicate_first_dynamic_condition);
continue;
}
if (tree_to_shwi (TYPE_SIZE (TREE_TYPE (val))) != c->size)
{
clause |= 1 << (i + predicate_first_dynamic_condition);
nonspec_clause |= 1 << (i + predicate_first_dynamic_condition);
continue;
}
if (c->code == IS_NOT_CONSTANT)
continue;
{
nonspec_clause |= 1 << (i + predicate_first_dynamic_condition);
continue;
}
val = fold_unary (VIEW_CONVERT_EXPR, TREE_TYPE (c->val), val);
res = val
......@@ -881,8 +924,11 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
continue;
clause |= 1 << (i + predicate_first_dynamic_condition);
nonspec_clause |= 1 << (i + predicate_first_dynamic_condition);
}
return clause;
*ret_clause = clause;
if (ret_nonspec_clause)
*ret_nonspec_clause = nonspec_clause;
}
......@@ -890,7 +936,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
static void
evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
clause_t *clause_ptr,
clause_t *clause_ptr, clause_t *nonspec_clause_ptr,
vec<tree> *known_vals_ptr,
vec<ipa_polymorphic_call_context>
*known_contexts_ptr,
......@@ -976,9 +1022,9 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
}
}
if (clause_ptr)
*clause_ptr = evaluate_conditions_for_known_args (callee, inline_p,
known_vals, known_aggs);
evaluate_conditions_for_known_args (callee, inline_p,
known_vals, known_aggs, clause_ptr,
nonspec_clause_ptr);
if (known_vals_ptr)
*known_vals_ptr = known_vals;
......@@ -1172,12 +1218,16 @@ inline_summary_t::duplicate (cgraph_node *src,
}
}
}
possible_truths = evaluate_conditions_for_known_args (dst, false,
known_vals,
vNULL);
evaluate_conditions_for_known_args (dst, false,
known_vals,
vNULL,
&possible_truths,
/* We are going to specialize,
so ignore nonspec truths. */
NULL);
known_vals.release ();
account_size_time (info, 0, 0, &true_pred);
account_size_time (info, 0, 0, &true_pred, &true_pred);
/* Remap size_time vectors.
Simplify the predicate by prunning out alternatives that are known
......@@ -1186,14 +1236,21 @@ inline_summary_t::duplicate (cgraph_node *src,
to be true. */
for (i = 0; vec_safe_iterate (entry, i, &e); i++)
{
struct predicate new_predicate;
new_predicate = remap_predicate_after_duplication (&e->predicate,
struct predicate new_exec_pred;
struct predicate new_nonconst_pred;
new_exec_pred = remap_predicate_after_duplication (&e->exec_predicate,
possible_truths,
info);
if (false_predicate_p (&new_predicate))
new_nonconst_pred
= remap_predicate_after_duplication (&e->nonconst_predicate,
possible_truths,
info);
if (false_predicate_p (&new_exec_pred)
|| false_predicate_p (&new_nonconst_pred))
optimized_out_size += e->size;
else
account_size_time (info, e->size, e->time, &new_predicate);
account_size_time (info, e->size, e->time, &new_exec_pred,
&new_nonconst_pred);
}
/* Remap edge predicates with the same simplification as above.
......@@ -1439,10 +1496,21 @@ dump_inline_summary (FILE *f, struct cgraph_node *node)
fprintf (f, " In SCC: %i\n", (int) s->scc_no);
for (i = 0; vec_safe_iterate (s->entry, i, &e); i++)
{
fprintf (f, " size:%f, time:%f, predicate:",
fprintf (f, " size:%f, time:%f",
(double) e->size / INLINE_SIZE_SCALE,
e->time.to_double () / INLINE_TIME_SCALE);
dump_predicate (f, s->conds, &e->predicate);
e->time.to_double ());
if (!true_predicate_p (&e->exec_predicate))
{
fprintf (f, ", executed if:");
dump_predicate (f, s->conds, &e->exec_predicate, 0);
}
if (!predicates_equal_p (&e->exec_predicate,
&e->nonconst_predicate))
{
fprintf (f, ", nonconst if:");
dump_predicate (f, s->conds, &e->nonconst_predicate, 0);
}
fprintf (f, "\n");
}
if (s->loop_iterations)
{
......@@ -2585,10 +2653,11 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
/* When we run into maximal number of entries, we assign everything to the
constant truth case. Be sure to have it in list. */
bb_predicate = true_predicate ();
account_size_time (info, 0, 0, &bb_predicate);
account_size_time (info, 0, 0, &bb_predicate, &bb_predicate);
bb_predicate = not_inlined_predicate ();
account_size_time (info, 2 * INLINE_SIZE_SCALE, 0, &bb_predicate);
account_size_time (info, 2 * INLINE_SIZE_SCALE, 0, &bb_predicate,
&bb_predicate);
if (fbi.info)
compute_bb_predicates (&fbi, node, info);
......@@ -2746,10 +2815,10 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
will_be_nonconstant
= will_be_nonconstant_predicate (&fbi, info,
stmt, nonconstant_names);
else
will_be_nonconstant = true_predicate ();
if (this_time || this_size)
{
struct predicate p;
this_time *= freq;
prob = eliminated_by_inlining_prob (stmt);
......@@ -2759,15 +2828,15 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
if (prob == 2 && dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "\t\tWill be eliminated by inlining\n");
if (fbi.info)
p = and_predicates (info->conds, &bb_predicate,
&will_be_nonconstant);
else
p = true_predicate ();
struct predicate p = and_predicates (info->conds, &bb_predicate,
&will_be_nonconstant);
/* We can ignore statement when we proved it is never going
to happen, but we can not do that for call statements
because edges are accounted specially. */
if (!false_predicate_p (&p)
|| (is_gimple_call (stmt)
&& !false_predicate_p (&bb_predicate)))
if (!false_predicate_p (is_gimple_call (stmt)
? &bb_predicate : &p))
{
time += this_time;
size += this_size;
......@@ -2781,13 +2850,18 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
if (prob)
{
struct predicate ip = not_inlined_predicate ();
ip = and_predicates (info->conds, &ip, &p);
ip = and_predicates (info->conds, &ip, &bb_predicate);
account_size_time (info, this_size * prob,
this_time * prob, &ip);
(sreal)(this_time * prob)
/ (CGRAPH_FREQ_BASE * 2), &ip,
&p);
}
if (prob != 2)
account_size_time (info, this_size * (2 - prob),
this_time * (2 - prob), &p);
(sreal)(this_time * (2 - prob))
/ (CGRAPH_FREQ_BASE * 2),
&bb_predicate,
&p);
}
if (!info->fp_expressions && fp_expression_p (stmt))
......@@ -2969,9 +3043,9 @@ compute_inline_parameters (struct cgraph_node *node, bool early)
es->call_stmt_size = eni_size_weights.call_cost;
es->call_stmt_time = eni_time_weights.call_cost;
account_size_time (info, INLINE_SIZE_SCALE * 2,
INLINE_TIME_SCALE * 2, &t);
2, &t, &t);
t = not_inlined_predicate ();
account_size_time (info, 2 * INLINE_SIZE_SCALE, 0, &t);
account_size_time (info, 2 * INLINE_SIZE_SCALE, 0, &t, &t);
inline_update_overall_summary (node);
info->self_size = info->size;
info->self_time = info->time;
......@@ -3048,7 +3122,7 @@ compute_inline_parameters (struct cgraph_node *node, bool early)
if (flag_checking)
{
inline_update_overall_summary (node);
gcc_assert (info->time == info->self_time
gcc_assert (!(info->time - info->self_time).to_int ()
&& info->size == info->self_size);
}
}
......@@ -3174,8 +3248,11 @@ estimate_edge_size_and_time (struct cgraph_edge *e, int *size, int *min_size,
*size += cur_size;
if (min_size)
*min_size += cur_size;
*time += call_time * prob / REG_BR_PROB_BASE
* e->frequency * (INLINE_TIME_SCALE / CGRAPH_FREQ_BASE);
if (prob == REG_BR_PROB_BASE)
*time += ((sreal)(call_time * e->frequency)) / CGRAPH_FREQ_BASE;
else
*time += ((sreal)call_time) * (prob * e->frequency)
/ (CGRAPH_FREQ_BASE * REG_BR_PROB_BASE);
}
......@@ -3257,10 +3334,13 @@ estimate_calls_size_and_time (struct cgraph_node *node, int *size,
static void
estimate_node_size_and_time (struct cgraph_node *node,
clause_t possible_truths,
clause_t nonspec_possible_truths,
vec<tree> known_vals,
vec<ipa_polymorphic_call_context> known_contexts,
vec<ipa_agg_jump_function_p> known_aggs,
int *ret_size, int *ret_min_size, sreal *ret_time,
int *ret_size, int *ret_min_size,
sreal *ret_time,
sreal *ret_nonspecialized_time,
inline_hints *ret_hints,
vec<inline_param_summary>
inline_param_summary)
......@@ -3292,31 +3372,57 @@ estimate_node_size_and_time (struct cgraph_node *node,
}
}
for (i = 0; vec_safe_iterate (info->entry, i, &e); i++)
if (evaluate_predicate (&e->predicate, possible_truths))
{
size += e->size;
gcc_checking_assert (e->time >= 0);
gcc_checking_assert (time >= 0);
if (!inline_param_summary.exists ())
time += e->time;
else
{
int prob = predicate_probability (info->conds,
&e->predicate,
possible_truths,
inline_param_summary);
gcc_checking_assert (prob >= 0);
gcc_checking_assert (prob <= REG_BR_PROB_BASE);
time += e->time * prob / REG_BR_PROB_BASE;
}
gcc_checking_assert (time >= 0);
estimate_calls_size_and_time (node, &size, &min_size, &time, &hints, possible_truths,
known_vals, known_contexts, known_aggs);
sreal nonspecialized_time = time;
}
gcc_checking_assert (true_predicate_p (&(*info->entry)[0].predicate));
for (i = 0; vec_safe_iterate (info->entry, i, &e); i++)
{
bool nonconst = evaluate_predicate (&e->nonconst_predicate,
possible_truths);
bool exec = evaluate_predicate (&e->exec_predicate,
nonspec_possible_truths);
gcc_assert (!nonconst || exec);
if (exec)
{
gcc_checking_assert (e->time >= 0);
gcc_checking_assert (time >= 0);
/* We compute specialized size only because size of nonspecialized
copy is context independent.
The difference between nonspecialized execution and specialized is
that nonspecialized is not going to have optimized out computations
known to be constant in a specialized setting. */
if (nonconst)
size += e->size;
nonspecialized_time += e->time;
if (!nonconst)
;
else if (!inline_param_summary.exists ())
{
if (nonconst)
time += e->time;
}
else
{
int prob = predicate_probability (info->conds,
&e->nonconst_predicate,
possible_truths,
inline_param_summary);
gcc_checking_assert (prob >= 0);
gcc_checking_assert (prob <= REG_BR_PROB_BASE);
time += e->time * prob / REG_BR_PROB_BASE;
}
gcc_checking_assert (time >= 0);
}
}
gcc_checking_assert (true_predicate_p (&(*info->entry)[0].exec_predicate));
gcc_checking_assert (true_predicate_p (&(*info->entry)[0].nonconst_predicate));
min_size = (*info->entry)[0].size;
gcc_checking_assert (size >= 0);
gcc_checking_assert (time >= 0);
gcc_checking_assert (nonspecialized_time >= time);
if (info->loop_iterations
&& !evaluate_predicate (info->loop_iterations, possible_truths))
......@@ -3332,18 +3438,16 @@ estimate_node_size_and_time (struct cgraph_node *node,
if (DECL_DECLARED_INLINE_P (node->decl))
hints |= INLINE_HINT_declared_inline;
estimate_calls_size_and_time (node, &size, &min_size, &time, &hints, possible_truths,
known_vals, known_contexts, known_aggs);
gcc_checking_assert (size >= 0);
gcc_checking_assert (time >= 0);
time = time / INLINE_TIME_SCALE;
size = RDIV (size, INLINE_SIZE_SCALE);
min_size = RDIV (min_size, INLINE_SIZE_SCALE);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "\n size:%i time:%f\n", (int) size, time.to_double ());
fprintf (dump_file, "\n size:%i time:%f nonspec time:%f\n", (int) size,
time.to_double (), nonspecialized_time.to_double ());
if (ret_time)
*ret_time = time;
if (ret_nonspecialized_time)
*ret_nonspecialized_time = nonspecialized_time;
if (ret_size)
*ret_size = size;
if (ret_min_size)
......@@ -3368,12 +3472,15 @@ estimate_ipcp_clone_size_and_time (struct cgraph_node *node,
int *ret_size, sreal *ret_time,
inline_hints *hints)
{
clause_t clause;
clause = evaluate_conditions_for_known_args (node, false, known_vals,
known_aggs);
estimate_node_size_and_time (node, clause, known_vals, known_contexts,
known_aggs, ret_size, NULL, ret_time, hints, vNULL);
clause_t clause, nonspec_clause;
sreal nonspec_time;
evaluate_conditions_for_known_args (node, false, known_vals, known_aggs,
&clause, &nonspec_clause);
estimate_node_size_and_time (node, clause, nonspec_clause,
known_vals, known_contexts,
known_aggs, ret_size, NULL, ret_time,
&nonspec_time, hints, vNULL);
}
/* Translate all conditions from callee representation into caller
......@@ -3645,7 +3752,7 @@ inline_merge_summary (struct cgraph_edge *edge)
struct cgraph_node *to = (edge->caller->global.inlined_to
? edge->caller->global.inlined_to : edge->caller);
struct inline_summary *info = inline_summaries->get (to);
clause_t clause = 0; /* not_inline is known to be false. */
clause_t clause = 0; /* not_inline is known to be false. */
size_time_entry *e;
vec<int> operand_map = vNULL;
vec<int> offset_map = vNULL;
......@@ -3662,7 +3769,7 @@ inline_merge_summary (struct cgraph_edge *edge)
info->fp_expressions |= callee_info->fp_expressions;
if (callee_info->conds)
evaluate_properties_for_edge (edge, true, &clause, NULL, NULL, NULL);
evaluate_properties_for_edge (edge, true, &clause, NULL, NULL, NULL, NULL);
if (ipa_node_params_sum && callee_info->conds)
{
struct ipa_edge_args *args = IPA_EDGE_REF (edge);
......@@ -3705,14 +3812,19 @@ inline_merge_summary (struct cgraph_edge *edge)
for (i = 0; vec_safe_iterate (callee_info->entry, i, &e); i++)
{
struct predicate p = remap_predicate (info, callee_info,
&e->predicate, operand_map,
&e->exec_predicate, operand_map,
offset_map, clause,
&toplev_predicate);
if (!false_predicate_p (&p))
struct predicate nonconstp
= remap_predicate (info, callee_info,
&e->nonconst_predicate, operand_map,
offset_map, clause,
&toplev_predicate);
if (!false_predicate_p (&p) && !false_predicate_p (&nonconstp))
{
sreal add_time = e->time * edge->frequency / CGRAPH_FREQ_BASE;
sreal add_time = ((sreal)e->time * edge->frequency) / CGRAPH_FREQ_BASE;
int prob = predicate_probability (callee_info->conds,
&e->predicate,
&e->nonconst_predicate,
clause, es->param);
add_time = add_time * prob / REG_BR_PROB_BASE;
if (prob != REG_BR_PROB_BASE
......@@ -3721,7 +3833,7 @@ inline_merge_summary (struct cgraph_edge *edge)
fprintf (dump_file, "\t\tScaling time by probability:%f\n",
(double) prob / REG_BR_PROB_BASE);
}
account_size_time (info, e->size, add_time, &p);
account_size_time (info, e->size, add_time, &p, &nonconstp);
}
}
remap_edge_summaries (edge, edge->callee, info, callee_info, operand_map,
......@@ -3761,13 +3873,13 @@ inline_update_overall_summary (struct cgraph_node *node)
info->time = 0;
for (i = 0; vec_safe_iterate (info->entry, i, &e); i++)
{
info->size += e->size, info->time += e->time;
info->size += e->size;
info->time += e->time;
}
estimate_calls_size_and_time (node, &info->size, &info->min_size,
&info->time, NULL,
~(clause_t) (1 << predicate_false_condition),
vNULL, vNULL, vNULL);
info->time = info->time / INLINE_TIME_SCALE;
info->size = (info->size + INLINE_SIZE_SCALE / 2) / INLINE_SIZE_SCALE;
}
......@@ -3803,11 +3915,11 @@ simple_edge_hints (struct cgraph_edge *edge)
sreal
do_estimate_edge_time (struct cgraph_edge *edge)
{
sreal time;
sreal time, nonspec_time;
int size;
inline_hints hints;
struct cgraph_node *callee;
clause_t clause;
clause_t clause, nonspec_clause;
vec<tree> known_vals;
vec<ipa_polymorphic_call_context> known_contexts;
vec<ipa_agg_jump_function_p> known_aggs;
......@@ -3818,10 +3930,11 @@ do_estimate_edge_time (struct cgraph_edge *edge)
gcc_checking_assert (edge->inline_failed);
evaluate_properties_for_edge (edge, true,
&clause, &known_vals, &known_contexts,
&known_aggs);
estimate_node_size_and_time (callee, clause, known_vals, known_contexts,
known_aggs, &size, &min_size, &time, &hints, es->param);
&clause, &nonspec_clause, &known_vals,
&known_contexts, &known_aggs);
estimate_node_size_and_time (callee, clause, nonspec_clause, known_vals,
known_contexts, known_aggs, &size, &min_size,
&time, &nonspec_time, &hints, es->param);
/* When we have profile feedback, we can quite safely identify hot
edges and for those we disable size limits. Don't do that when
......@@ -3846,6 +3959,7 @@ do_estimate_edge_time (struct cgraph_edge *edge)
if ((int) edge_growth_cache.length () <= edge->uid)
edge_growth_cache.safe_grow_cleared (symtab->edges_max_uid);
edge_growth_cache[edge->uid].time = time;
edge_growth_cache[edge->uid].nonspec_time = nonspec_time;
edge_growth_cache[edge->uid].size = size + (size >= 0);
hints |= simple_edge_hints (edge);
......@@ -3863,7 +3977,7 @@ do_estimate_edge_size (struct cgraph_edge *edge)
{
int size;
struct cgraph_node *callee;
clause_t clause;
clause_t clause, nonspec_clause;
vec<tree> known_vals;
vec<ipa_polymorphic_call_context> known_contexts;
vec<ipa_agg_jump_function_p> known_aggs;
......@@ -3883,10 +3997,12 @@ do_estimate_edge_size (struct cgraph_edge *edge)
/* Early inliner runs without caching, go ahead and do the dirty work. */
gcc_checking_assert (edge->inline_failed);
evaluate_properties_for_edge (edge, true,
&clause, &known_vals, &known_contexts,
&clause, &nonspec_clause,
&known_vals, &known_contexts,
&known_aggs);
estimate_node_size_and_time (callee, clause, known_vals, known_contexts,
known_aggs, &size, NULL, NULL, NULL, vNULL);
estimate_node_size_and_time (callee, clause, nonspec_clause, known_vals,
known_contexts, known_aggs, &size, NULL, NULL,
NULL, NULL, vNULL);
known_vals.release ();
known_contexts.release ();
known_aggs.release ();
......@@ -3902,7 +4018,7 @@ do_estimate_edge_hints (struct cgraph_edge *edge)
{
inline_hints hints;
struct cgraph_node *callee;
clause_t clause;
clause_t clause, nonspec_clause;
vec<tree> known_vals;
vec<ipa_polymorphic_call_context> known_contexts;
vec<ipa_agg_jump_function_p> known_aggs;
......@@ -3922,10 +4038,12 @@ do_estimate_edge_hints (struct cgraph_edge *edge)
/* Early inliner runs without caching, go ahead and do the dirty work. */
gcc_checking_assert (edge->inline_failed);
evaluate_properties_for_edge (edge, true,
&clause, &known_vals, &known_contexts,
&clause, &nonspec_clause,
&known_vals, &known_contexts,
&known_aggs);
estimate_node_size_and_time (callee, clause, known_vals, known_contexts,
known_aggs, NULL, NULL, NULL, &hints, vNULL);
estimate_node_size_and_time (callee, clause, nonspec_clause, known_vals,
known_contexts, known_aggs, NULL, NULL,
NULL, NULL, &hints, vNULL);
known_vals.release ();
known_contexts.release ();
known_aggs.release ();
......@@ -4304,7 +4422,8 @@ inline_read_section (struct lto_file_decl_data *file_data, const char *data,
e.size = streamer_read_uhwi (&ib);
e.time = sreal::stream_in (&ib);
e.predicate = read_predicate (&ib);
e.exec_predicate = read_predicate (&ib);
e.nonconst_predicate = read_predicate (&ib);
vec_safe_push (info->entry, e);
}
......@@ -4463,7 +4582,8 @@ inline_write_summary (void)
{
streamer_write_uhwi (ob, e->size);
e->time.stream_out (ob);
write_predicate (ob, &e->predicate);
write_predicate (ob, &e->exec_predicate);
write_predicate (ob, &e->nonconst_predicate);
}
write_predicate (ob, info->loop_iterations);
write_predicate (ob, info->loop_stride);
......
gcc/ipa-inline.c
......@@ -639,10 +639,9 @@ want_early_inline_function_p (struct cgraph_edge *e)
does not happen. */
inline sreal
compute_uninlined_call_time (struct inline_summary *callee_info,
struct cgraph_edge *edge)
compute_uninlined_call_time (struct cgraph_edge *edge,
sreal uninlined_call_time)
{
sreal uninlined_call_time = (sreal)callee_info->time;
cgraph_node *caller = (edge->caller->global.inlined_to
? edge->caller->global.inlined_to
: edge->caller);
......@@ -677,12 +676,10 @@ compute_inlined_call_time (struct cgraph_edge *edge,
else
time = time >> 11;
/* This calculation should match one in ipa-inline-analysis.
FIXME: Once ipa-inline-analysis is converted to sreal this can be
simplified. */
time -= (sreal) ((gcov_type) edge->frequency
* inline_edge_summary (edge)->call_stmt_time
* (INLINE_TIME_SCALE / CGRAPH_FREQ_BASE)) / INLINE_TIME_SCALE;
/* This calculation should match one in ipa-inline-analysis.c
(estimate_edge_size_and_time). */
time -= (sreal) edge->frequency
* inline_edge_summary (edge)->call_stmt_time / CGRAPH_FREQ_BASE;
time += caller_time;
if (time <= 0)
time = ((sreal) 1) >> 8;
......@@ -696,12 +693,13 @@ compute_inlined_call_time (struct cgraph_edge *edge,
static bool
big_speedup_p (struct cgraph_edge *e)
{
sreal time = compute_uninlined_call_time (inline_summaries->get (e->callee),
e);
sreal inlined_time = compute_inlined_call_time (e, estimate_edge_time (e));
sreal unspec_time;
sreal spec_time = estimate_edge_time (e, &unspec_time);
sreal time = compute_uninlined_call_time (e, unspec_time);
sreal inlined_time = compute_inlined_call_time (e, spec_time);
if (time - inlined_time
> (sreal) time * PARAM_VALUE (PARAM_INLINE_MIN_SPEEDUP)
> (sreal) (time * PARAM_VALUE (PARAM_INLINE_MIN_SPEEDUP))
* percent_rec)
return true;
return false;
......@@ -1011,7 +1009,7 @@ edge_badness (struct cgraph_edge *edge, bool dump)
{
sreal badness;
int growth;
sreal edge_time;
sreal edge_time, unspec_edge_time;
struct cgraph_node *callee = edge->callee->ultimate_alias_target ();
struct inline_summary *callee_info = inline_summaries->get (callee);
inline_hints hints;
......@@ -1020,12 +1018,11 @@ edge_badness (struct cgraph_edge *edge, bool dump)
: edge->caller);
growth = estimate_edge_growth (edge);
edge_time = estimate_edge_time (edge);
edge_time = estimate_edge_time (edge, &unspec_edge_time);
hints = estimate_edge_hints (edge);
gcc_checking_assert (edge_time >= 0);
/* FIXME: -1 to care of rounding issues should go away once cache is migrated.
to sreals. */
gcc_checking_assert (edge_time <= callee_info->time);
/* Check that inlined time is better, but tolerate some roundoff issues. */
gcc_checking_assert ((edge_time - callee_info->time).to_int () <= 0);
gcc_checking_assert (growth <= callee_info->size);
if (dump)
......@@ -1035,9 +1032,10 @@ edge_badness (struct cgraph_edge *edge, bool dump)
edge->caller->order,
xstrdup_for_dump (callee->name ()),
edge->callee->order);
fprintf (dump_file, " size growth %i, time %f ",
fprintf (dump_file, " size growth %i, time %f unspec %f ",
growth,
edge_time.to_double ());
edge_time.to_double (),
unspec_edge_time.to_double ());
dump_inline_hints (dump_file, hints);
if (big_speedup_p (edge))
fprintf (dump_file, " big_speedup");
......@@ -1076,7 +1074,7 @@ edge_badness (struct cgraph_edge *edge, bool dump)
sreal numerator, denominator;
int overall_growth;
numerator = (compute_uninlined_call_time (callee_info, edge)
numerator = (compute_uninlined_call_time (edge, unspec_edge_time)
- compute_inlined_call_time (edge, edge_time));
if (numerator == 0)
numerator = ((sreal) 1 >> 8);
......@@ -1162,13 +1160,14 @@ edge_badness (struct cgraph_edge *edge, bool dump)
fprintf (dump_file,
" %f: guessed profile. frequency %f, count %" PRId64
" caller count %" PRId64
" time w/o inlining %f, time w/ inlining %f"
" time w/o inlining %f, time with inlining %f"
" overall growth %i (current) %i (original)"
" %i (compensated)\n",
badness.to_double (),
(double)edge->frequency / CGRAPH_FREQ_BASE,
edge->count, caller->count,
compute_uninlined_call_time (callee_info, edge).to_double (),
compute_uninlined_call_time (edge,
unspec_edge_time).to_double (),
compute_inlined_call_time (edge, edge_time).to_double (),
estimate_growth (callee),
callee_info->growth, overall_growth);
......@@ -2056,8 +2055,9 @@ inline_small_functions (void)
if (dump_file)
{
fprintf (dump_file,
" Inlined into %s which now has time %f and size %i, "
" Inlined %s into %s which now has time %f and size %i, "
"net change of %+i.\n",
edge->callee->name (),
edge->caller->name (),
inline_summaries->get (edge->caller)->time.to_double (),
inline_summaries->get (edge->caller)->size,
......
gcc/ipa-inline.h
......@@ -103,13 +103,16 @@ struct GTY(()) predicate
context. We keep simple array of record, every containing of predicate
and time/size to account.
We keep values scaled up, so fractional sizes and times can be
accounted. */
We keep values scaled up, so fractional sizes can be accounted. */
#define INLINE_SIZE_SCALE 2
#define INLINE_TIME_SCALE (CGRAPH_FREQ_BASE * 2)
struct GTY(()) size_time_entry
{
struct predicate predicate;
/* Predicate for code to be executed. */
struct predicate exec_predicate;
/* Predicate for value to be constant and optimized out in a specialized copy.
When deciding on specialization this makes it possible to see how much
the executed code paths will simplify. */
struct predicate nonconst_predicate;
int size;
sreal GTY((skip)) time;
};
......@@ -230,9 +233,11 @@ struct inline_edge_summary
typedef struct inline_edge_summary inline_edge_summary_t;
extern vec<inline_edge_summary_t> inline_edge_summary_vec;
/* Data we cache about callgraph edges during inlining to avoid expensive
re-computations during the greedy algorithm. */
struct edge_growth_cache_entry
{
sreal time;
sreal time, nonspec_time;
int size;
inline_hints hints;
};
......@@ -315,12 +320,14 @@ estimate_edge_growth (struct cgraph_edge *edge)
EDGE. */
static inline sreal
estimate_edge_time (struct cgraph_edge *edge)
estimate_edge_time (struct cgraph_edge *edge, sreal *nonspec_time = NULL)
{
sreal ret;
if ((int)edge_growth_cache.length () <= edge->uid
|| !edge_growth_cache[edge->uid].size)
return do_estimate_edge_time (edge);
if (nonspec_time)
*nonspec_time = edge_growth_cache[edge->uid].nonspec_time;
return edge_growth_cache[edge->uid].time;
}
......@@ -345,7 +352,7 @@ reset_edge_growth_cache (struct cgraph_edge *edge)
{
if ((int)edge_growth_cache.length () > edge->uid)
{
struct edge_growth_cache_entry zero = {0, 0, 0};
struct edge_growth_cache_entry zero = {0, 0, 0, 0};
edge_growth_cache[edge->uid] = zero;
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment