From 370df3ce7c4e01db1a62b2c639aa2391073cf498 Mon Sep 17 00:00:00 2001 From: Jan Hubicka Date: Thu, 9 Nov 2017 17:36:07 +0100 Subject: [PATCH] bb-reorder.c (max_entry_frequency): Remove. * bb-reorder.c (max_entry_frequency): Remove. (find_traces, rotate_loop, mark_bb_visited, connect_better_edge_p, connect_traces, push_to_next_round_p): Remove prototypes. (find_traces_1_round): Use counts only. (push_to_next_round_p): Likewise. (find_traces): Likewise. (rotate_loop): Likewise. (find_traces_1_round): Likewise. (connect_traces): Likewise. (edge_order): Likewise. From-SVN: r254602 --- gcc/ChangeLog | 13 ++++++++ gcc/bb-reorder.c | 84 ++++++++++++++---------------------------------- 2 files changed, 38 insertions(+), 59 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 67d925c0014..6a58579d64e 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +2017-11-09 Jan Hubicka + + * bb-reorder.c (max_entry_frequency): Remove. + (find_traces, rotate_loop, mark_bb_visited, connect_better_edge_p, + connect_traces, push_to_next_round_p): Remove prototypes. + (find_traces_1_round): Use counts only. + (push_to_next_round_p): Likewise. + (find_traces): Likewise. + (rotate_loop): Likewise. + (find_traces_1_round): Likewise. + (connect_traces): Likewise. + (edge_order): Likewise. + 2017-11-09 Thomas Preud'homme * config/arm/arm.c (output_return_instruction): Add comments to diff --git a/gcc/bb-reorder.c b/gcc/bb-reorder.c index f7c1f4c971e..ce20100c188 100644 --- a/gcc/bb-reorder.c +++ b/gcc/bb-reorder.c @@ -197,24 +197,16 @@ struct trace }; /* Maximum frequency and count of one of the entry blocks. */ -static int max_entry_frequency; static profile_count max_entry_count; /* Local function prototypes. */ -static void find_traces (int *, struct trace *); -static basic_block rotate_loop (edge, struct trace *, int); -static void mark_bb_visited (basic_block, int); -static void find_traces_1_round (int, int, gcov_type, struct trace *, int *, +static void find_traces_1_round (int, profile_count, struct trace *, int *, int, bb_heap_t **, int); static basic_block copy_bb (basic_block, edge, basic_block, int); static long bb_to_key (basic_block); static bool better_edge_p (const_basic_block, const_edge, profile_probability, int, profile_probability, int, const_edge); -static bool connect_better_edge_p (const_edge, bool, int, const_edge, - struct trace *); -static void connect_traces (int, struct trace *); static bool copy_bb_p (const_basic_block, int); -static bool push_to_next_round_p (const_basic_block, int, int, int, gcov_type); /* Return the trace number in which BB was visited. */ @@ -249,15 +241,14 @@ mark_bb_visited (basic_block bb, int trace) static bool push_to_next_round_p (const_basic_block bb, int round, int number_of_rounds, - int exec_th, gcov_type count_th) + profile_count count_th) { bool there_exists_another_round; bool block_not_hot_enough; there_exists_another_round = round < number_of_rounds - 1; - block_not_hot_enough = (bb->count.to_frequency (cfun) < exec_th - || bb->count.ipa () < count_th + block_not_hot_enough = (bb->count < count_th || probably_never_executed_bb_p (cfun, bb)); if (there_exists_another_round @@ -287,33 +278,26 @@ find_traces (int *n_traces, struct trace *traces) number_of_rounds = N_ROUNDS - 1; /* Insert entry points of function into heap. */ - max_entry_frequency = 0; max_entry_count = profile_count::zero (); FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs) { bbd[e->dest->index].heap = heap; bbd[e->dest->index].node = heap->insert (bb_to_key (e->dest), e->dest); - if (e->dest->count.to_frequency (cfun) > max_entry_frequency) - max_entry_frequency = e->dest->count.to_frequency (cfun); - if (e->dest->count.ipa_p () && e->dest->count > max_entry_count) + if (e->dest->count > max_entry_count) max_entry_count = e->dest->count; } /* Find the traces. */ for (i = 0; i < number_of_rounds; i++) { - gcov_type count_threshold; + profile_count count_threshold; if (dump_file) fprintf (dump_file, "STC - round %d\n", i + 1); - if (max_entry_count < INT_MAX / 1000) - count_threshold = max_entry_count.to_gcov_type () * exec_threshold[i] / 1000; - else - count_threshold = max_entry_count.to_gcov_type () / 1000 * exec_threshold[i]; + count_threshold = max_entry_count.apply_scale (exec_threshold[i], 1000); find_traces_1_round (REG_BR_PROB_BASE * branch_threshold[i] / 1000, - max_entry_frequency * exec_threshold[i] / 1000, count_threshold, traces, n_traces, i, &heap, number_of_rounds); } @@ -349,7 +333,6 @@ rotate_loop (edge back_edge, struct trace *trace, int trace_n) /* Information about the best end (end after rotation) of the loop. */ basic_block best_bb = NULL; edge best_edge = NULL; - int best_freq = -1; profile_count best_count = profile_count::uninitialized (); /* The best edge is preferred when its destination is not visited yet or is a start block of some trace. */ @@ -375,12 +358,9 @@ rotate_loop (edge back_edge, struct trace *trace, int trace_n) || bbd[e->dest->index].start_of_trace >= 0) { /* The current edge E is also preferred. */ - int freq = EDGE_FREQUENCY (e); - if (freq > best_freq || e->count () > best_count) + if (e->count () > best_count) { - best_freq = freq; - if (e->count ().initialized_p ()) - best_count = e->count (); + best_count = e->count (); best_edge = e; best_bb = bb; } @@ -393,17 +373,14 @@ rotate_loop (edge back_edge, struct trace *trace, int trace_n) { /* The current edge E is preferred. */ is_preferred = true; - best_freq = EDGE_FREQUENCY (e); best_count = e->count (); best_edge = e; best_bb = bb; } else { - int freq = EDGE_FREQUENCY (e); - if (!best_edge || freq > best_freq || e->count () > best_count) + if (!best_edge || e->count () > best_count) { - best_freq = freq; best_count = e->count (); best_edge = e; best_bb = bb; @@ -464,7 +441,7 @@ rotate_loop (edge back_edge, struct trace *trace, int trace_n) *HEAP and store starting points for the next round into new *HEAP. */ static void -find_traces_1_round (int branch_th, int exec_th, gcov_type count_th, +find_traces_1_round (int branch_th, profile_count count_th, struct trace *traces, int *n_traces, int round, bb_heap_t **heap, int number_of_rounds) { @@ -494,7 +471,7 @@ find_traces_1_round (int branch_th, int exec_th, gcov_type count_th, round. When optimizing for size, do not push to next round. */ if (!for_size - && push_to_next_round_p (bb, round, number_of_rounds, exec_th, + && push_to_next_round_p (bb, round, number_of_rounds, count_th)) { int key = bb_to_key (bb); @@ -574,8 +551,7 @@ find_traces_1_round (int branch_th, int exec_th, gcov_type count_th, if (!(e->flags & EDGE_CAN_FALLTHRU) || (e->flags & EDGE_COMPLEX) || !prob.initialized_p () || ((prob.to_reg_br_prob_base () < branch_th - || EDGE_FREQUENCY (e) < exec_th - || e->count ().ipa () < count_th) && (!for_size))) + || e->count () < count_th) && (!for_size))) continue; if (better_edge_p (bb, e, prob, freq, best_prob, best_freq, @@ -666,14 +642,12 @@ find_traces_1_round (int branch_th, int exec_th, gcov_type count_th, bb_heap_t *which_heap = *heap; prob = e->probability; - freq = EDGE_FREQUENCY (e); if (!(e->flags & EDGE_CAN_FALLTHRU) || (e->flags & EDGE_COMPLEX) || !prob.initialized_p () || prob.to_reg_br_prob_base () < branch_th - || freq < exec_th - || e->count ().ipa () < count_th) + || e->count () < count_th) { /* When partitioning hot/cold basic blocks, make sure the cold blocks (and only the cold blocks) all get @@ -682,7 +656,7 @@ find_traces_1_round (int branch_th, int exec_th, gcov_type count_th, if (!for_size && push_to_next_round_p (e->dest, round, number_of_rounds, - exec_th, count_th)) + count_th)) which_heap = new_heap; } @@ -707,8 +681,8 @@ find_traces_1_round (int branch_th, int exec_th, gcov_type count_th, /* We do nothing with one basic block loops. */ if (best_edge->dest != bb) { - if (EDGE_FREQUENCY (best_edge) - > 4 * best_edge->dest->count.to_frequency (cfun) / 5) + if (best_edge->count () + > best_edge->dest->count.apply_scale (4, 5)) { /* The loop has at least 4 iterations. If the loop header is not the first block of the function @@ -759,9 +733,8 @@ find_traces_1_round (int branch_th, int exec_th, gcov_type count_th, C where - EDGE_FREQUENCY (AB) + EDGE_FREQUENCY (BC) - >= EDGE_FREQUENCY (AC). - (i.e. 2 * B->frequency >= EDGE_FREQUENCY (AC) ) + AB->count () + BC->count () >= AC->count (). + (i.e. 2 * B->count >= AC->count ) Best ordering is then A B C. When optimizing for size, A B C is always the best order. @@ -785,8 +758,8 @@ find_traces_1_round (int branch_th, int exec_th, gcov_type count_th, & EDGE_CAN_FALLTHRU) && !(single_succ_edge (e->dest)->flags & EDGE_COMPLEX) && single_succ (e->dest) == best_edge->dest - && (2 * e->dest->count.to_frequency (cfun) - >= EDGE_FREQUENCY (best_edge) || for_size)) + && (e->dest->count.apply_scale (2, 1) + >= best_edge->count () || for_size)) { best_edge = e; if (dump_file) @@ -1086,15 +1059,10 @@ connect_traces (int n_traces, struct trace *traces) int last_trace; int current_pass; int current_partition; - int freq_threshold; - gcov_type count_threshold; + profile_count count_threshold; bool for_size = optimize_function_for_size_p (cfun); - freq_threshold = max_entry_frequency * DUPLICATION_THRESHOLD / 1000; - if (max_entry_count.to_gcov_type () < INT_MAX / 1000) - count_threshold = max_entry_count.to_gcov_type () * DUPLICATION_THRESHOLD / 1000; - else - count_threshold = max_entry_count.to_gcov_type () / 1000 * DUPLICATION_THRESHOLD; + count_threshold = max_entry_count.apply_scale (DUPLICATION_THRESHOLD, 1000); connected = XCNEWVEC (bool, n_traces); last_trace = -1; @@ -1291,8 +1259,7 @@ connect_traces (int n_traces, struct trace *traces) && bbd[di].start_of_trace >= 0 && !connected[bbd[di].start_of_trace] && BB_PARTITION (e2->dest) == current_partition - && EDGE_FREQUENCY (e2) >= freq_threshold - && e2->count ().ipa () >= count_threshold + && e2->count () >= count_threshold && (!best2 || e2->probability > best2->probability || (e2->probability == best2->probability @@ -1317,9 +1284,8 @@ connect_traces (int n_traces, struct trace *traces) && BB_PARTITION (best->src) == BB_PARTITION (best->dest) && copy_bb_p (best->dest, optimize_edge_for_speed_p (best) - && EDGE_FREQUENCY (best) >= freq_threshold && (!best->count ().initialized_p () - || best->count ().ipa () >= count_threshold))) + || best->count () >= count_threshold))) { basic_block new_bb; @@ -2312,7 +2278,7 @@ reorder_basic_blocks_software_trace_cache (void) static bool edge_order (edge e1, edge e2) { - return EDGE_FREQUENCY (e1) > EDGE_FREQUENCY (e2); + return e1->count () > e2->count (); } /* Reorder basic blocks using the "simple" algorithm. This tries to -- 2.30.2