From: hubicka Date: Mon, 29 Apr 2002 10:19:56 +0000 (+0000) Subject: * predict.c (real_zero, real_one, real_almost_one, real_br_prob_base, X-Git-Tag: upstream/4.9.2~87025 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=56ff48808dd6ca510788d33b4023cc17601d2420;p=platform%2Fupstream%2Flinaro-gcc.git * predict.c (real_zero, real_one, real_almost_one, real_br_prob_base, real_one_half, real_bb_freq_max): New static variables. (debug_profile_bbauxs): Kill. (process_note_predictions): Kill unused variable. (block_info_def, edge_info_def): Use REAL_VALUE_TYPE instead of volatile double. (propagate_freq): Use REAL_ARITHMETICS. (estimate_bb_frequencies): Likevise; init new static variables. * Makefile.in (predict.o): Add dependency on real.h git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@52889 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 130ce8e..d59171b 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,15 @@ +Mon Apr 29 12:18:35 CEST 2002 Jan Hubicka + + * predict.c (real_zero, real_one, real_almost_one, real_br_prob_base, + real_one_half, real_bb_freq_max): New static variables. + (debug_profile_bbauxs): Kill. + (process_note_predictions): Kill unused variable. + (block_info_def, edge_info_def): Use REAL_VALUE_TYPE instead of + volatile double. + (propagate_freq): Use REAL_ARITHMETICS. + (estimate_bb_frequencies): Likevise; init new static variables. + * Makefile.in (predict.o): Add dependency on real.h + 2002-04-28 David S. Miller PR target/6500 diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 319e14f..f7ebd99 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1576,7 +1576,7 @@ reg-stack.o : reg-stack.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) $(RECOG_H) varray.h function.h $(TM_P_H) predict.o: predict.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) flags.h \ insn-config.h $(BASIC_BLOCK_H) $(REGS_H) hard-reg-set.h output.h toplev.h \ - $(RECOG_H) function.h except.h $(EXPR_H) $(TM_P_H) $(PREDICT_H) + $(RECOG_H) function.h except.h $(EXPR_H) $(TM_P_H) $(PREDICT_H) real.h lists.o: lists.c $(CONFIG_H) $(SYSTEM_H) toplev.h $(RTL_H) $(GGC_H) bb-reorder.o : bb-reorder.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) \ flags.h $(BASIC_BLOCK_H) hard-reg-set.h output.h cfglayout.h $(TARGET_H) diff --git a/gcc/predict.c b/gcc/predict.c index 1d8691c..3eece35 100644 --- a/gcc/predict.c +++ b/gcc/predict.c @@ -45,6 +45,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "recog.h" #include "expr.h" #include "predict.h" +#include "real.h" + +/* real constants: 0, 1, 1-1/REG_BR_PROB_BASE, REG_BR_PROB_BASE, 0.5, + REAL_BB_FREQ_MAX. */ +static REAL_VALUE_TYPE real_zero, real_one, real_almost_one, real_br_prob_base, + real_one_half, real_bb_freq_max; /* Random guesstimation given names. */ #define PROB_NEVER (0) @@ -620,7 +626,7 @@ expected_value_to_br_prob () typedef struct block_info_def { /* Estimated frequency of execution of basic_block. */ - volatile double frequency; + REAL_VALUE_TYPE frequency; /* To keep queue of basic blocks to process. */ basic_block next; @@ -637,11 +643,8 @@ typedef struct edge_info_def { /* In case edge is an loopback edge, the probability edge will be reached in case header is. Estimated number of iterations of the loop can be - then computed as 1 / (1 - back_edge_prob). - - Volatile is needed to avoid differences in the optimized and unoptimized - builds on machines where FP registers are wider than double. */ - volatile double back_edge_prob; + then computed as 1 / (1 - back_edge_prob). */ + REAL_VALUE_TYPE back_edge_prob; /* True if the edge is an loopback edge in the natural loop. */ int back_edge:1; } *edge_info; @@ -683,10 +686,13 @@ propagate_freq (head) } } - BLOCK_INFO (head)->frequency = 1; + memcpy (&BLOCK_INFO (head)->frequency, &real_one, sizeof (real_one)); for (; bb; bb = nextbb) { - double cyclic_probability = 0, frequency = 0; + REAL_VALUE_TYPE cyclic_probability, frequency; + + memcpy (&cyclic_probability, &real_zero, sizeof (real_zero)); + memcpy (&frequency, &real_zero, sizeof (real_zero)); nextbb = BLOCK_INFO (bb)->next; BLOCK_INFO (bb)->next = NULL; @@ -702,16 +708,36 @@ propagate_freq (head) for (e = bb->pred; e; e = e->pred_next) if (EDGE_INFO (e)->back_edge) - cyclic_probability += EDGE_INFO (e)->back_edge_prob; + { + REAL_ARITHMETIC (cyclic_probability, PLUS_EXPR, + cyclic_probability, + EDGE_INFO (e)->back_edge_prob); + } else if (!(e->flags & EDGE_DFS_BACK)) - frequency += (e->probability - * BLOCK_INFO (e->src)->frequency / - REG_BR_PROB_BASE); + { + REAL_VALUE_TYPE tmp; + + /* frequency += (e->probability + * BLOCK_INFO (e->src)->frequency / + REG_BR_PROB_BASE); */ + + REAL_VALUE_FROM_INT (tmp, e->probability, 0, DFmode); + REAL_ARITHMETIC (tmp, MULT_EXPR, tmp, + BLOCK_INFO (e->src)->frequency); + REAL_ARITHMETIC (tmp, RDIV_EXPR, tmp, real_br_prob_base); + REAL_ARITHMETIC (frequency, PLUS_EXPR, frequency, tmp); + } + + if (REAL_VALUES_LESS (real_almost_one, cyclic_probability)) + memcpy (&cyclic_probability, &real_almost_one, sizeof (real_zero)); - if (cyclic_probability > 1.0 - 1.0 / REG_BR_PROB_BASE) - cyclic_probability = 1.0 - 1.0 / REG_BR_PROB_BASE; + /* BLOCK_INFO (bb)->frequency = frequency / (1 - cyclic_probability) + */ - BLOCK_INFO (bb)->frequency = frequency / (1 - cyclic_probability); + REAL_ARITHMETIC (cyclic_probability, MINUS_EXPR, real_one, + cyclic_probability); + REAL_ARITHMETIC (BLOCK_INFO (bb)->frequency, + RDIV_EXPR, frequency, cyclic_probability); } BLOCK_INFO (bb)->tovisit = 0; @@ -719,9 +745,19 @@ propagate_freq (head) /* Compute back edge frequencies. */ for (e = bb->succ; e; e = e->succ_next) if (e->dest == head) - EDGE_INFO (e)->back_edge_prob - = ((e->probability * BLOCK_INFO (bb)->frequency) - / REG_BR_PROB_BASE); + { + REAL_VALUE_TYPE tmp; + + /* EDGE_INFO (e)->back_edge_prob + = ((e->probability * BLOCK_INFO (bb)->frequency) + / REG_BR_PROB_BASE); */ + REAL_VALUE_FROM_INT (tmp, e->probability, 0, DFmode); + REAL_ARITHMETIC (tmp, MULT_EXPR, tmp, + BLOCK_INFO (bb)->frequency); + REAL_ARITHMETIC (EDGE_INFO (e)->back_edge_prob, + RDIV_EXPR, tmp, real_br_prob_base); + + } /* Propagate to successor blocks. */ for (e = bb->succ; e; e = e->succ_next) @@ -863,7 +899,18 @@ estimate_bb_frequencies (loops) struct loops *loops; { int i; - double freq_max = 0; + REAL_VALUE_TYPE freq_max; + + REAL_VALUE_FROM_INT (real_zero, 0, 0, DFmode); + REAL_VALUE_FROM_INT (real_one, 1, 0, DFmode); + REAL_VALUE_FROM_INT (real_br_prob_base, REG_BR_PROB_BASE, 0, DFmode); + REAL_VALUE_FROM_INT (real_bb_freq_max, BB_FREQ_MAX, 0, DFmode); + REAL_VALUE_FROM_INT (real_one_half, 2, 0, DFmode); + + REAL_ARITHMETIC (real_one_half, RDIV_EXPR, real_one, real_one_half); + + REAL_ARITHMETIC (real_almost_one, RDIV_EXPR, real_one, real_br_prob_base); + REAL_ARITHMETIC (real_almost_one, MINUS_EXPR, real_one, real_almost_one); mark_dfs_back_edges (); if (flag_branch_probabilities) @@ -919,8 +966,14 @@ estimate_bb_frequencies (loops) BLOCK_INFO (bb)->tovisit = 0; for (e = bb->succ; e; e = e->succ_next) - EDGE_INFO (e)->back_edge_prob = ((double) e->probability - / REG_BR_PROB_BASE); + { + + REAL_VALUE_FROM_INT (EDGE_INFO (e)->back_edge_prob, + e->probability, 0, DFmode); + REAL_ARITHMETIC (EDGE_INFO (e)->back_edge_prob, + RDIV_EXPR, EDGE_INFO (e)->back_edge_prob, + real_br_prob_base); + } } /* First compute probabilities locally for each loop from innermost @@ -935,14 +988,16 @@ estimate_bb_frequencies (loops) BLOCK_INFO (EXIT_BLOCK_PTR)->tovisit = 1; propagate_freq (ENTRY_BLOCK_PTR); + memcpy (&freq_max, &real_zero, sizeof (real_zero)); for (i = 0; i < n_basic_blocks; i++) - if (BLOCK_INFO (BASIC_BLOCK (i))->frequency > freq_max) - freq_max = BLOCK_INFO (BASIC_BLOCK (i))->frequency; + if (REAL_VALUES_LESS (freq_max, BLOCK_INFO (BASIC_BLOCK (i))->frequency)) + memcpy (&freq_max, &BLOCK_INFO (BASIC_BLOCK (i))->frequency, + sizeof (freq_max)); for (i = -2; i < n_basic_blocks; i++) { basic_block bb; - volatile double tmp; + REAL_VALUE_TYPE tmp; if (i == -2) bb = ENTRY_BLOCK_PTR; @@ -951,11 +1006,11 @@ estimate_bb_frequencies (loops) else bb = BASIC_BLOCK (i); - /* ??? Prevent rounding differences due to optimization on x86. */ - tmp = BLOCK_INFO (bb)->frequency * BB_FREQ_MAX; - tmp /= freq_max; - tmp += 0.5; - bb->frequency = tmp; + REAL_ARITHMETIC (tmp, MULT_EXPR, BLOCK_INFO (bb)->frequency, + real_bb_freq_max); + REAL_ARITHMETIC (tmp, RDIV_EXPR, tmp, freq_max); + REAL_ARITHMETIC (tmp, PLUS_EXPR, tmp, real_one_half); + bb->frequency = REAL_VALUE_UNSIGNED_FIX (tmp); } free_aux_for_blocks ();