2005-11-05 Jan Hubicka <jh@suse.cz>
+ PR rtl-optimization/23490
+ * doc/invoke.texi (max-predicted-iterations, max-cse-insns,
+ max-flow-memory-location): Document.
+ * flow.c: Include params.h
+ (MAX_MEM_SET_LIST_LEN): Kill.
+ (add_to_mem_set_list): Use new param.
+ * cse.c (cse_basic_block): Replace 1000 by new param.
+ * params.def (PARAM_MAX_PREDICTED_ITERATIONS, PARAM_MAX_CSE_INSNS,
+ PARAM_MAX_FLOW_MEMORY_LOCATIONS): New.
+ * predict.c (predict_loops): Use new param.
+ * predict.def (MAX_PRED_LOOP_ITERATIONS): Remove.
+
* ipa-inline.c (cgraph_decide_inlining_of_small_function,
cgraph_decide_inlining, cgraph_decide_inlining_incrementally):
Do not hold memory returned by cgraph_node_name across other call.
??? This is a real kludge and needs to be done some other way.
Perhaps for 2.9. */
- if (code != NOTE && num_insns++ > 1000)
+ if (code != NOTE && num_insns++ > PARAM_VALUE (PARAM_MAX_CSE_INSNS))
{
flush_hash_table ();
num_insns = 0;
Select fraction of the maximal frequency of executions of basic block in
function given basic block needs to have to be considered hot
+@item max-predicted-iterations
+The maximum number of loop iterations we predict statically. This is useful
+in cases where function contain single loop with known bound and other loop
+with unknown. We predict the known number of iterations correctly, while
+the unknown nummber of iterations average to roughly 10. This means that the
+loop without bounds would appear artifically cold relative to the other one.
+
@item tracer-dynamic-coverage
@itemx tracer-dynamic-coverage-feedback
Maximum number of basic blocks on path that cse considers. The default is 10.
+@item max-cse-insns
+The maximum instructions CSE process before flushing. The default is 1000.
+
@item global-var-threshold
Counts the number of function calls (@var{n}) and the number of
Increasing values mean more aggressive optimization, making the compile time
increase with probably slightly better performance. The default value is 500.
+@item max-flow-memory-location
+Similar as @option{max-cselib-memory-location} but for dataflow liveness.
+The default value is 100.
+
@item reorder-blocks-duplicate
@itemx reorder-blocks-duplicate-feedback
#include "obstack.h"
#include "splay-tree.h"
#include "tree-pass.h"
+#include "params.h"
#ifndef HAVE_epilogue
#define HAVE_epilogue 0
static int *reg_deaths;
-/* Maximum length of pbi->mem_set_list before we start dropping
- new elements on the floor. */
-#define MAX_MEM_SET_LIST_LEN 100
-
/* Forward declarations */
static int verify_wide_reg_1 (rtx *, void *);
static void verify_wide_reg (int, basic_block);
/* We repeat regardless of what cleanup_cfg says. If there were
instructions deleted above, that might have been only a
- partial improvement (see MAX_MEM_SET_LIST_LEN usage).
+ partial improvement (see PARAM_MAX_FLOW_MEMORY_LOCATIONS usage).
Further improvement may be possible. */
cleanup_cfg (CLEANUP_EXPENSIVE);
}
}
- if (pbi->mem_set_list_len < MAX_MEM_SET_LIST_LEN)
+ if (pbi->mem_set_list_len < PARAM_VALUE (PARAM_MAX_FLOW_MEMORY_LOCATIONS))
{
#ifdef AUTO_INC_DEC
/* Store a copy of mem, otherwise the address may be
"hot-bb-frequency-fraction",
"Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot",
1000, 0, 0)
+
+/* For guessed profiles, the loops having unknown number of iterations
+ are predicted to iterate relatively few (10) times at average.
+ For functions containing one loop with large known number of iterations
+ and other loops having unbounded loops we would end up predicting all
+ the other loops cold that is not usually the case. So we need to artifically
+ flatten the profile.
+
+ We need to cut the maximal predicted iterations to large enought iterations
+ so the loop appears important, but safely within HOT_BB_COUNT_FRACTION
+ range. */
+
+DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS,
+ "max-predicted-iterations",
+ "The maximum number of loop iterations we predict statically",
+ 100, 0, 0)
DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK,
"tracer-dynamic-coverage-feedback",
"The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available",
"max-cse-path-length",
"The maximum length of path considered in cse",
10, 0, 0)
+DEFPARAM(PARAM_MAX_CSE_INSNS,
+ "max-flow-memory-locations",
+ "The maximum instructions CSE process before flushing",
+ 1000, 0, 0)
/* The cost of expression in loop invariant motion that is considered
expensive. */
"max-cselib-memory-locations",
"The maximum memory locations recorded by cselib",
500, 0, 0)
+DEFPARAM(PARAM_MAX_FLOW_MEMORY_LOCATIONS,
+ "max-flow-memory-locations",
+ "The maximum memory locations recorded by flow",
+ 100, 0, 0)
#ifdef ENABLE_GC_ALWAYS_COLLECT
# define GGC_MIN_EXPAND_DEFAULT 0
niter = desc.niter + 1;
if (niter == 0) /* We might overflow here. */
niter = desc.niter;
- if (niter > MAX_PRED_LOOP_ITERATIONS)
- niter = MAX_PRED_LOOP_ITERATIONS;
+ if (niter
+ > (unsigned int) PARAM_VALUE (PARAM_MAX_PREDICTED_ITERATIONS))
+ niter = PARAM_VALUE (PARAM_MAX_PREDICTED_ITERATIONS);
prob = (REG_BR_PROB_BASE
- (REG_BR_PROB_BASE + niter /2) / niter);
if (TREE_CODE (niter) == INTEGER_CST)
{
int probability;
+ int max = PARAM_VALUE (PARAM_MAX_PREDICTED_ITERATIONS);
if (host_integerp (niter, 1)
&& tree_int_cst_lt (niter,
- build_int_cstu (NULL_TREE,
- MAX_PRED_LOOP_ITERATIONS - 1)))
+ build_int_cstu (NULL_TREE, max - 1)))
{
HOST_WIDE_INT nitercst = tree_low_cst (niter, 1) + 1;
probability = ((REG_BR_PROB_BASE + nitercst / 2)
/ nitercst);
}
else
- probability = ((REG_BR_PROB_BASE
- + MAX_PRED_LOOP_ITERATIONS / 2)
- / MAX_PRED_LOOP_ITERATIONS);
+ probability = ((REG_BR_PROB_BASE + max / 2) / max);
predict_edge (exits[j], PRED_LOOP_ITERATIONS, probability);
}
DEF_PREDICTOR (PRED_LOOP_ITERATIONS, "loop iterations", PROB_ALWAYS,
PRED_FLAG_FIRST_MATCH)
-/* For guessed profiles, the loops having unknown number of iterations
- are predicted to iterate relatively few (10) times at average.
- For functions containing one loop with large known number of iterations
- and other loops having unbounded loops we would end up predicting all
- the other loops cold that is not usually the case. So we need to artifically
- flatten the profile.
-
- We need to cut the maximal predicted iterations to large enought iterations
- so the loop appears important, but safely within HOT_BB_COUNT_FRACTION
- range. */
-#define MAX_PRED_LOOP_ITERATIONS 100
-
/* Hints dropped by user via __builtin_expect feature. */
DEF_PREDICTOR (PRED_BUILTIN_EXPECT, "__builtin_expect", PROB_VERY_LIKELY,
PRED_FLAG_FIRST_MATCH)
projects / gcc.git / commitdiff