From 84895d28940b46040028e8736adbd83dc2d77b23 Mon Sep 17 00:00:00 2001 From: hubicka Date: Mon, 6 Nov 2017 13:45:41 +0000 Subject: PR bootstrap/82832 * ipa-inline-transform.c (update_noncloned_frequencies): Always scale. (inline_transform): Likewise. * predict.c (counts_to_freqs): Remove useless conditional. * profile-count.h (profile_count::apply_scale): Move sanity check. * tree-inline.c (copy_bb): Always scale. (copy_cfg_body): Likewise. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@254452 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ipa-inline-transform.c | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) (limited to 'gcc/ipa-inline-transform.c') diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c index 886e8edd473..e367df7df0e 100644 --- a/gcc/ipa-inline-transform.c +++ b/gcc/ipa-inline-transform.c @@ -59,7 +59,18 @@ update_noncloned_frequencies (struct cgraph_node *node, profile_count den) { struct cgraph_edge *e; - bool scale = (num == profile_count::zero () || den > 0); + + /* We always must scale to be sure counters end up compatible. + If den is zero, just force it nonzero and hope for reasonable + approximation. + When num is forced nonzero, also update den, so we do not scale profile + to 0. */ + if (!(num == den) + && !(den.force_nonzero () == den)) + { + den = den.force_nonzero (); + num = num.force_nonzero (); + } /* We do not want to ignore high loop nest after freq drops to 0. */ if (!freq_scale) @@ -71,19 +82,16 @@ update_noncloned_frequencies (struct cgraph_node *node, e->frequency = CGRAPH_FREQ_MAX; if (!e->inline_failed) update_noncloned_frequencies (e->callee, freq_scale, num, den); - if (scale) - e->count = e->count.apply_scale (num, den); + e->count = e->count.apply_scale (num, den); } for (e = node->indirect_calls; e; e = e->next_callee) { e->frequency = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE; if (e->frequency > CGRAPH_FREQ_MAX) e->frequency = CGRAPH_FREQ_MAX; - if (scale) - e->count = e->count.apply_scale (num, den); + e->count = e->count.apply_scale (num, den); } - if (scale) - node->count = node->count.apply_scale (num, den); + node->count = node->count.apply_scale (num, den); } /* We removed or are going to remove the last call to NODE. @@ -692,7 +700,10 @@ inline_transform (struct cgraph_node *node) basic_block bb; FOR_ALL_BB_FN (bb, cfun) - bb->count = bb->count.apply_scale (num, den); + if (num == profile_count::zero ()) + bb->count = bb->count.global0 (); + else + bb->count = bb->count.apply_scale (num, den); ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = node->count; } todo = optimize_inline_calls (current_function_decl); -- cgit v1.2.1 From 371858d4588d4757de1f809368d8678232b65cc8 Mon Sep 17 00:00:00 2001 From: hubicka Date: Thu, 9 Nov 2017 14:05:14 +0000 Subject: PR ipa/82879 * ipa-inline-transform.c (update_noncloned_frequencies): Use profile_count::adjust_for_ipa_scaling. * tree-inline.c (copy_bb, copy_cfg_body): Likewise. * profile-count.c (profile_count::adjust_for_ipa_scaling): New member function. * profile-count.h (profile_count::adjust_for_ipa_scaling): Declare. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@254582 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ipa-inline-transform.c | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) (limited to 'gcc/ipa-inline-transform.c') diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c index e367df7df0e..b2363e23043 100644 --- a/gcc/ipa-inline-transform.c +++ b/gcc/ipa-inline-transform.c @@ -60,17 +60,7 @@ update_noncloned_frequencies (struct cgraph_node *node, { struct cgraph_edge *e; - /* We always must scale to be sure counters end up compatible. - If den is zero, just force it nonzero and hope for reasonable - approximation. - When num is forced nonzero, also update den, so we do not scale profile - to 0. */ - if (!(num == den) - && !(den.force_nonzero () == den)) - { - den = den.force_nonzero (); - num = num.force_nonzero (); - } + profile_count::adjust_for_ipa_scaling (&num, &den); /* We do not want to ignore high loop nest after freq drops to 0. */ if (!freq_scale) -- cgit v1.2.1 From 151b9ff52a095baa99b7cd3f392f82b221d81f98 Mon Sep 17 00:00:00 2001 From: hubicka Date: Fri, 10 Nov 2017 20:14:52 +0000 Subject: * auto-profile.c (afdo_indirect_call): Drop frequency. * cgraph.c (symbol_table::create_edge): Drop frequency argument. (cgraph_node::create_edge): Drop frequency argument. (cgraph_node::create_indirect_edge): Drop frequency argument. (cgraph_edge::make_speculative): Drop frequency arguments. (cgraph_edge::resolve_speculation): Do not update frequencies (cgraph_edge::dump_edge_flags): Do not dump frequency. (cgraph_node::dump): Check consistency in IPA mode. (cgraph_edge::maybe_hot_p): Use IPA counter. (cgraph_edge::verify_count_and_frequency): Rename to ... (cgraph_edge::verify_count): ... this one; drop frequency checking. (cgraph_node::verify_node): Update. * cgraph.h (struct cgraph_edge): Drop frequency. (cgraph_edge::frequency): New function. * cgraphbuild.c (pass_build_cgraph_edges::execute): Donot pass frequencies. (cgraph_edge::rebuild_edges): Likewise. * cgraphclones.c (cgraph_edge::clone): Scale only counts. (duplicate_thunk_for_node): Do not pass frequency. (cgraph_node::create_clone): Scale only counts. (cgraph_node::create_virtual_clone): Do not pass frequency. (cgraph_node::create_edge_including_clones): Do not pass frequency. (cgraph_node::create_version_clone): Do not pass frequency. * cgraphunit.c (cgraph_node::analyze): Do not pass frequency. (cgraph_node::expand_thunk): Do not pass frequency. (cgraph_node::create_wrapper): Do not pass frequency. * gimple-iterator.c (update_call_edge_frequencies): Do not pass frequency. * gimple-streamer-in.c (input_bb): Scale only IPA counts. * ipa-chkp.c (chkp_produce_thunks): Do not pass frequency. * ipa-cp.c (ipcp_lattice::print): Use frequency function. (gather_caller_stats): Use frequency function. (ipcp_cloning_candidate_p): Use frequency function. (ipcp_propagate_stage): Use frequency function. (get_info_about_necessary_edges): Use frequency function. (update_profiling_info): Update only IPA profile. (update_specialized_profile): Use frequency functoin. (perhaps_add_new_callers): Update only IPA profile. * ipa-devirt.c (ipa_devirt): Use IPA profile. * ipa-fnsummary.c (redirect_to_unreachable): Do not set frequrency. (dump_ipa_call_summary): Use frequency function. (estimate_edge_size_and_time): Use frequency function. (ipa_merge_fn_summary_after_inlining): Use frequency function. * ipa-inline-analysis.c (do_estimate_edge_time): Use IPA profile. * ipa-inline-transform.c (update_noncloned_frequencies): Rename to .. (update_noncloned_counts): ... ths one; scale counts only. (clone_inlined_nodes): Do not scale frequency. (inline_call): Do not pass frequency. * ipa-inline.c (compute_uninlined_call_time): Use IPA profile. (compute_inlined_call_time): Use IPA profile. (want_inline_small_function_p): Use IPA profile. (want_inline_self_recursive_call_p): Use IPA profile. (edge_badness): Use IPA profile. (lookup_recursive_calls): Use IPA profile. (recursive_inlining): Do not pass frequency. (resolve_noninline_speculation): Do not update frequency. (inline_small_functions): Collect max of IPA profile. (dump_overall_stats): Dump IPA porfile. (dump_inline_stats): Dump IPA porfile. (ipa_inline): Collect IPA stats. * ipa-inline.h (clone_inlined_nodes): Update prototype. * ipa-profile.c (ipa_propagate_frequency_1): Use frequency function. (ipa_propagate_frequency): Use frequency function. (ipa_profile): Cleanup. * ipa-prop.c (ipa_make_edge_direct_to_target): Do not pass frequency * ipa-utils.c (ipa_merge_profiles): Merge all profiles. * lto-cgraph.c (lto_output_edge): Do not stream frequency. (input_node): Do not stream frequency. (input_edge): Do not stream frequency. (merge_profile_summaries): Scale only IPA profiles. * omp-simd-clone.c (simd_clone_adjust): Do not pass frequency. * predict.c (drop_profile): Do not recompute frequency. * trans-mem.c (ipa_tm_insert_irr_call): Do not pass frequency. (ipa_tm_insert_gettmclone_call): Do not pass frequency. * tree-cfg.c (execute_fixup_cfg): Drop profile to global0 if needed. * tree-chkp.c (chkp_copy_bounds_for_assign): Do not pass frequency. * tree-emutls.c (gen_emutls_addr): Do not pass frequency. * tree-inline.c (copy_bb): Do not scale frequency. (expand_call_inline): Do not scale frequency. (tree_function_versioning): Do not scale frequency. * ubsan.c (ubsan_create_edge): Do not pass frequency. lto/ChangeLog: 2017-11-10 Jan Hubicka * lto-partition.c (lto_balanced_map): Use frequency accessor. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@254636 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ipa-inline-transform.c | 39 +++++++++++---------------------------- 1 file changed, 11 insertions(+), 28 deletions(-) (limited to 'gcc/ipa-inline-transform.c') diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c index b2363e23043..8e66483016a 100644 --- a/gcc/ipa-inline-transform.c +++ b/gcc/ipa-inline-transform.c @@ -51,36 +51,24 @@ along with GCC; see the file COPYING3. If not see int ncalls_inlined; int nfunctions_inlined; -/* Scale frequency of NODE edges by FREQ_SCALE. */ +/* Scale counts of NODE edges by NUM/DEN. */ static void -update_noncloned_frequencies (struct cgraph_node *node, - int freq_scale, profile_count num, - profile_count den) +update_noncloned_counts (struct cgraph_node *node, + profile_count num, profile_count den) { struct cgraph_edge *e; profile_count::adjust_for_ipa_scaling (&num, &den); - /* We do not want to ignore high loop nest after freq drops to 0. */ - if (!freq_scale) - freq_scale = 1; for (e = node->callees; e; e = e->next_callee) { - e->frequency = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE; - if (e->frequency > CGRAPH_FREQ_MAX) - e->frequency = CGRAPH_FREQ_MAX; if (!e->inline_failed) - update_noncloned_frequencies (e->callee, freq_scale, num, den); + update_noncloned_counts (e->callee, num, den); e->count = e->count.apply_scale (num, den); } for (e = node->indirect_calls; e; e = e->next_callee) - { - e->frequency = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE; - if (e->frequency > CGRAPH_FREQ_MAX) - e->frequency = CGRAPH_FREQ_MAX; - e->count = e->count.apply_scale (num, den); - } + e->count = e->count.apply_scale (num, den); node->count = node->count.apply_scale (num, den); } @@ -169,12 +157,11 @@ master_clone_with_noninline_clones_p (struct cgraph_node *node) By default the offline copy is removed, when it appears dead after inlining. UPDATE_ORIGINAL prevents this transformation. If OVERALL_SIZE is non-NULL, the size is updated to reflect the - transformation. - FREQ_SCALE specify the scaling of frequencies of call sites. */ + transformation. */ void clone_inlined_nodes (struct cgraph_edge *e, bool duplicate, - bool update_original, int *overall_size, int freq_scale) + bool update_original, int *overall_size) { struct cgraph_node *inlining_into; struct cgraph_edge *next; @@ -218,8 +205,7 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate, } duplicate = false; e->callee->externally_visible = false; - update_noncloned_frequencies (e->callee, e->frequency, - e->count, e->callee->count); + update_noncloned_counts (e->callee, e->count, e->callee->count); dump_callgraph_transformation (e->callee, inlining_into, "inlining to"); @@ -228,11 +214,8 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate, { struct cgraph_node *n; - if (freq_scale == -1) - freq_scale = e->frequency; n = e->callee->create_clone (e->callee->decl, - MIN (e->count, e->callee->count), - freq_scale, + e->count, update_original, vNULL, true, inlining_into, NULL); @@ -250,7 +233,7 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate, { next = e->next_callee; if (!e->inline_failed) - clone_inlined_nodes (e, duplicate, update_original, overall_size, freq_scale); + clone_inlined_nodes (e, duplicate, update_original, overall_size); } } @@ -457,7 +440,7 @@ inline_call (struct cgraph_edge *e, bool update_original, } } - clone_inlined_nodes (e, true, update_original, overall_size, e->frequency); + clone_inlined_nodes (e, true, update_original, overall_size); gcc_assert (curr->callee->global.inlined_to == to); -- cgit v1.2.1