CbC/CbC_gcc: gcc/tree-ssa-loop-prefetch.c comparison

comparison gcc/tree-ssa-loop-prefetch.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 #include "tm.h"
 #include "tree.h"
 #include "tm_p.h"
 #include "basic-block.h"
 #include "output.h"
-#include "diagnostic.h"
 #include "tree-pretty-print.h"
 #include "tree-flow.h"
 #include "tree-dump.h"
 #include "timevar.h"
 #include "cfgloop.h"
-#include "expr.h"
 #include "tree-pass.h"
 #include "insn-config.h"
 #include "recog.h"
 #include "hashtab.h"
 #include "tree-chrec.h"
 #include "tree-scalar-evolution.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "params.h"
 #include "langhooks.h"
 #include "tree-inline.h"
 #include "tree-data-ref.h"
+/* FIXME: Needed for optabs, but this should all be moved to a TBD interface
+between the GIMPLE and RTL worlds.  */
+#include "expr.h"
 #include "optabs.h"
 /* This pass inserts prefetch instructions to optimize cache usage during
 accesses to arrays in loops.  It processes loops sequentially and:
 location 64 iterations before it, and PREFETCH_MOD 64 (since
 	   it hits the same cache line otherwise).
 (2) has PREFETCH_MOD 64
 (3) has PREFETCH_MOD 4
 (4) has PREFETCH_MOD 1.  We do not set PREFETCH_BEFORE here, since
-the cache line accessed by (4) is the same with probability only
+the cache line accessed by (5) is the same with probability only
 	   7/32.
 (5) has PREFETCH_MOD 1 as well.
 Additionally, we use data dependence analysis to determine for each
 reference the distance till the first reuse; this information is used
 6) We actually emit the prefetch instructions.  ??? Perhaps emit the
 prefetch instructions with guards in cases where 5) was not sufficient
 to satisfy the constraints?
-The function is_loop_prefetching_profitable() implements a cost model
+A cost model is implemented to determine whether or not prefetching is
-to determine if prefetching is profitable for a given loop. The cost
+profitable for a given loop.  The cost model has three heuristics:
-model has two heuristcs:
-1. A heuristic that determines whether the given loop has enough CPU
+1. Function trip_count_to_ahead_ratio_too_small_p implements a
-ops that can be overlapped with cache missing memory ops.
+heuristic that determines whether or not the loop has too few
-If not, the loop won't benefit from prefetching. This is implemented
+iterations (compared to ahead).  Prefetching is not likely to be
-by requirung the ratio between the instruction count and the mem ref
+beneficial if the trip count to ahead ratio is below a certain
-count to be above a certain minimum.
+minimum.
-2. A heuristic that disables prefetching in a loop with an unknown trip
-count if the prefetching cost is above a certain limit. The relative
+2. Function mem_ref_count_reasonable_p implements a heuristic that
-prefetching cost is estimated by taking the ratio between the
+determines whether the given loop has enough CPU ops that can be
-prefetch count and the total intruction count (this models the I-cache
+overlapped with cache missing memory ops.  If not, the loop
-cost).
+won't benefit from prefetching.  In the implementation,
+prefetching is not considered beneficial if the ratio between
+the instruction count and the mem ref count is below a certain
+minimum.
+3. Function insn_to_prefetch_ratio_too_small_p implements a
+heuristic that disables prefetching in a loop if the prefetching
+cost is above a certain limit.  The relative prefetching cost is
+estimated by taking the ratio between the prefetch count and the
+total intruction count (this models the I-cache cost).
 The limits used in these heuristics are defined as parameters with
 reasonable default values. Machine-specific default values will be
 added later.
 Some other TODO:
 #define PREFETCH_ALL		(~(unsigned HOST_WIDE_INT) 0)
 /* Do not generate a prefetch if the unroll factor is significantly less
 than what is required by the prefetch.  This is to avoid redundant
-prefetches.  For example, if prefetch_mod is 16 and unroll_factor is
+prefetches.  For example, when prefetch_mod is 16 and unroll_factor is
-1, this means prefetching requires unrolling the loop 16 times, but
+2, prefetching requires unrolling the loop 16 times, but
-the loop is not going to be unrolled.  In this case (ratio = 16),
+the loop is actually unrolled twice.  In this case (ratio = 8),
 prefetching is not likely to be beneficial.  */
 #ifndef PREFETCH_MOD_TO_UNROLL_FACTOR_RATIO
-#define PREFETCH_MOD_TO_UNROLL_FACTOR_RATIO 8
+#define PREFETCH_MOD_TO_UNROLL_FACTOR_RATIO 4
+#endif
+/* Some of the prefetch computations have quadratic complexity.  We want to
+avoid huge compile times and, therefore, want to limit the amount of
+memory references per loop where we consider prefetching.  */
+#ifndef PREFETCH_MAX_MEM_REFS_PER_LOOP
+#define PREFETCH_MAX_MEM_REFS_PER_LOOP 200
 #endif
 /* The memory reference.  */
 struct mem_ref
 struct ar_data *ar_data = (struct ar_data *) data;
 tree ibase, step, stepsize;
 HOST_WIDE_INT idelta = 0, imult = 1;
 affine_iv iv;
-if (TREE_CODE (base) == MISALIGNED_INDIRECT_REF
-|| TREE_CODE (base) == ALIGN_INDIRECT_REF)
-return false;
 if (!simple_iv (ar_data->loop, loop_containing_stmt (ar_data->stmt),
 		  *index, &iv, true))
 return false;
 ibase = iv.base;
 step = iv.step;
 }
 if (cst_and_fits_in_hwi (ibase))
 {
 idelta += int_cst_value (ibase);
 ibase = build_int_cst (TREE_TYPE (ibase), 0);
+}
+if (TREE_CODE (base) == ARRAY_REF)
+{
+stepsize = array_ref_element_size (base);
+if (!cst_and_fits_in_hwi (stepsize))
+	return false;
+imult = int_cst_value (stepsize);
+step = fold_build2 (MULT_EXPR, sizetype,
+			  fold_convert (sizetype, step),
+			  fold_convert (sizetype, stepsize));
+idelta *= imult;
 }
 if (*ar_data->step == NULL_TREE)
 *ar_data->step = step;
 else
 *ar_data->step = fold_build2 (PLUS_EXPR, sizetype,
 				  fold_convert (sizetype, *ar_data->step),
 				  fold_convert (sizetype, step));
-if (TREE_CODE (base) == ARRAY_REF)
-{
-stepsize = array_ref_element_size (base);
-if (!cst_and_fits_in_hwi (stepsize))
-	return false;
-imult = int_cst_value (stepsize);
-*ar_data->step = fold_build2 (MULT_EXPR, sizetype,
-				    fold_convert (sizetype, *ar_data->step),
-				    fold_convert (sizetype, step));
-idelta *= imult;
-}
 *ar_data->delta += idelta;
 *index = ibase;
 return true;
 }
 tree ref = *ref_p;
 *step = NULL_TREE;
 *delta = 0;
-/* First strip off the component references.  Ignore bitfields.  */
+/* First strip off the component references.  Ignore bitfields.
-if (TREE_CODE (ref) == COMPONENT_REF
+Also strip off the real and imagine parts of a complex, so that
-&& DECL_NONADDRESSABLE_P (TREE_OPERAND (ref, 1)))
+they can have the same base.  */
-ref = TREE_OPERAND (ref, 0);
+if (TREE_CODE (ref) == REALPART_EXPR
+|| TREE_CODE (ref) == IMAGPART_EXPR
+|| (TREE_CODE (ref) == COMPONENT_REF
+&& DECL_NONADDRESSABLE_P (TREE_OPERAND (ref, 1))))
+{
+if (TREE_CODE (ref) == IMAGPART_EXPR)
+*delta += int_size_in_bytes (TREE_TYPE (ref));
+ref = TREE_OPERAND (ref, 0);
+}
 *ref_p = ref;
 for (; TREE_CODE (ref) == COMPONENT_REF; ref = TREE_OPERAND (ref, 0))
 {
 if (!analyze_ref (loop, &ref, &base, &step, &delta, stmt))
 return false;
 /* If analyze_ref fails the default is a NULL_TREE.  We can stop here.  */
 if (step == NULL_TREE)
+return false;
+/* Stop if the address of BASE could not be taken.  */
+if (may_be_nonaddressable_p (base))
+return false;
+/* Limit non-constant step prefetching only to the innermost loops.  */
+if (!cst_and_fits_in_hwi (step) && loop->inner != NULL)
 return false;
 /* Now we know that REF = &BASE + STEP * iter + DELTA, where DELTA and STEP
 are integer constants.  */
 agrp = find_or_create_group (refs, base, step);
 }
 /* Given a CACHE_LINE_SIZE and two inductive memory references
 with a common STEP greater than CACHE_LINE_SIZE and an address
 difference DELTA, compute the probability that they will fall
-in different cache lines.  DISTINCT_ITERS is the number of
+in different cache lines.  Return true if the computed miss rate
-distinct iterations after which the pattern repeats itself.
+is not greater than the ACCEPTABLE_MISS_RATE.  DISTINCT_ITERS is the
+number of distinct iterations after which the pattern repeats itself.
 ALIGN_UNIT is the unit of alignment in bytes.  */
-static int
+static bool
-compute_miss_rate (unsigned HOST_WIDE_INT cache_line_size,
+is_miss_rate_acceptable (unsigned HOST_WIDE_INT cache_line_size,
 		   HOST_WIDE_INT step, HOST_WIDE_INT delta,
 		   unsigned HOST_WIDE_INT distinct_iters,
 		   int align_unit)
 {
 unsigned align, iter;
-int total_positions, miss_positions, miss_rate;
+int total_positions, miss_positions, max_allowed_miss_positions;
 int address1, address2, cache_line1, cache_line2;
-total_positions = 0;
+/* It always misses if delta is greater than or equal to the cache
+line size.  */
+if (delta >= (HOST_WIDE_INT) cache_line_size)
+return false;
 miss_positions = 0;
+total_positions = (cache_line_size / align_unit) * distinct_iters;
+max_allowed_miss_positions = (ACCEPTABLE_MISS_RATE * total_positions) / 1000;
 /* Iterate through all possible alignments of the first
 memory reference within its cache line.  */
 for (align = 0; align < cache_line_size; align += align_unit)
 {
 	address1 = align + step * iter;
 	address2 = address1 + delta;
 	cache_line1 = address1 / cache_line_size;
 	cache_line2 = address2 / cache_line_size;
-	total_positions += 1;
 	if (cache_line1 != cache_line2)
-	  miss_positions += 1;
+	  {
+	    miss_positions += 1;
+if (miss_positions > max_allowed_miss_positions)
+	      return false;
+}
 }
-miss_rate = 1000 * miss_positions / total_positions;
+return true;
-return miss_rate;
 }
 /* Prune the prefetch candidate REF using the reuse with BY.
 If BY_IS_BEFORE is true, BY is before REF in the loop.  */
 bool backward;
 HOST_WIDE_INT delta_r = ref->delta, delta_b = by->delta;
 HOST_WIDE_INT delta = delta_b - delta_r;
 HOST_WIDE_INT hit_from;
 unsigned HOST_WIDE_INT prefetch_before, prefetch_block;
-int miss_rate;
 HOST_WIDE_INT reduced_step;
 unsigned HOST_WIDE_INT reduced_prefetch_block;
 tree ref_type;
 int align_unit;
 prefetch_before = delta / step;
 delta %= step;
 ref_type = TREE_TYPE (ref->mem);
 align_unit = TYPE_ALIGN (ref_type) / 8;
-miss_rate = compute_miss_rate(prefetch_block, step, delta,
+if (is_miss_rate_acceptable (prefetch_block, step, delta,
-				reduced_prefetch_block, align_unit);
+			       reduced_prefetch_block, align_unit))
-if (miss_rate <= ACCEPTABLE_MISS_RATE)
 {
 /* Do not reduce prefetch_before if we meet beyond cache size.  */
 if (prefetch_before > L2_CACHE_SIZE_BYTES / PREFETCH_BLOCK)
 prefetch_before = PREFETCH_ALL;
 if (prefetch_before < ref->prefetch_before)
 }
 /* Try also the following iteration.  */
 prefetch_before++;
 delta = step - delta;
-miss_rate = compute_miss_rate(prefetch_block, step, delta,
+if (is_miss_rate_acceptable (prefetch_block, step, delta,
-				reduced_prefetch_block, align_unit);
+			       reduced_prefetch_block, align_unit))
-if (miss_rate <= ACCEPTABLE_MISS_RATE)
 {
 if (prefetch_before < ref->prefetch_before)
 	ref->prefetch_before = prefetch_before;
 return;
 }
 return any;
 }
-/* Estimate the number of prefetches in the given GROUPS.  */
+/* Return TRUE if no prefetch is going to be generated in the given
+GROUPS.  */
-static int
-estimate_prefetch_count (struct mem_ref_group *groups)
+static bool
+nothing_to_prefetch_p (struct mem_ref_group *groups)
 {
 struct mem_ref *ref;
-int prefetch_count = 0;
 for (; groups; groups = groups->next)
 for (ref = groups->refs; ref; ref = ref->next)
 if (should_issue_prefetch_p (ref))
-	  prefetch_count++;
+	return false;
+return true;
+}
+/* Estimate the number of prefetches in the given GROUPS.
+UNROLL_FACTOR is the factor by which LOOP was unrolled.  */
+static int
+estimate_prefetch_count (struct mem_ref_group *groups, unsigned unroll_factor)
+{
+struct mem_ref *ref;
+unsigned n_prefetches;
+int prefetch_count = 0;
+for (; groups; groups = groups->next)
+for (ref = groups->refs; ref; ref = ref->next)
+if (should_issue_prefetch_p (ref))
+	{
+	  n_prefetches = ((unroll_factor + ref->prefetch_mod - 1)
+			  / ref->prefetch_mod);
+	  prefetch_count += n_prefetches;
+	}
 return prefetch_count;
 }
 /* Issue prefetches for the reference REF into loop as decided before.
 		  / ref->prefetch_mod);
 addr_base = build_fold_addr_expr_with_type (ref->mem, ptr_type_node);
 addr_base = force_gimple_operand_gsi (&bsi, unshare_expr (addr_base),
 					true, NULL, true, GSI_SAME_STMT);
 write_p = ref->write_p ? integer_one_node : integer_zero_node;
-local = build_int_cst (integer_type_node, nontemporal ? 0 : 3);
+local = nontemporal ? integer_zero_node : integer_three_node;
 for (ap = 0; ap < n_prefetches; ap++)
 {
 if (cst_and_fits_in_hwi (ref->group->step))
 {
 /* Check that we have the storent instruction for the mode.  */
 mode = TYPE_MODE (TREE_TYPE (ref->mem));
 if (mode == BLKmode)
 return false;
-code = optab_handler (storent_optab, mode)->insn_code;
+code = optab_handler (storent_optab, mode);
 return code != CODE_FOR_nothing;
 }
 /* If REF is a nontemporal store, we mark the corresponding modify statement
 and return true.  Otherwise, we return false.  */
 edge exit;
 gimple call;
 gimple_stmt_iterator bsi;
 unsigned i;
-for (i = 0; VEC_iterate (edge, exits, i, exit); i++)
+FOR_EACH_VEC_ELT (edge, exits, i, exit)
 {
 call = gimple_build_call (FENCE_FOLLOWING_MOVNT, 0);
 if (!single_pred_p (exit->dest)
 	  /* If possible, we prefer not to insert the fence on other paths
 {
 VEC (edge, heap) *exits = get_loop_exit_edges (loop);
 unsigned i;
 edge exit;
-for (i = 0; VEC_iterate (edge, exits, i, exit); i++)
+FOR_EACH_VEC_ELT (edge, exits, i, exit)
 	if ((exit->flags & EDGE_ABNORMAL)
 	    && exit->dest == EXIT_BLOCK_PTR)
 	  ret = false;
 VEC_free (edge, heap, exits);
 the innermost loop in that the stride is less than cache size.  */
 strides = XCNEWVEC (HOST_WIDE_INT, n);
 access_fns = DR_ACCESS_FNS (dr);
-for (i = 0; VEC_iterate (tree, access_fns, i, access_fn); i++)
+FOR_EACH_VEC_ELT (tree, access_fns, i, access_fn)
 {
 /* Keep track of the reference corresponding to the subscript, so that we
 	 know its stride.  */
 while (handled_component_p (ref) && TREE_CODE (ref) != ARRAY_REF)
 	ref = TREE_OPERAND (ref, 0);
 are used just as a heuristics to estimate temporality of the
 references, hence we do not need to worry about correctness).  */
 for (gr = refs; gr; gr = gr->next)
 for (ref = gr->refs; ref; ref = ref->next)
 {
-	dr = create_data_ref (nest, ref->mem, ref->stmt, !ref->write_p);
+	dr = create_data_ref (nest, loop_containing_stmt (ref->stmt),
+			      ref->mem, ref->stmt, !ref->write_p);
 	if (dr)
 	  {
 	    ref->reuse_distance = volume;
 	    dr->aux = ref;
 	  }
 	else
 	  no_other_refs = false;
 }
-for (i = 0; VEC_iterate (data_reference_p, datarefs, i, dr); i++)
+FOR_EACH_VEC_ELT (data_reference_p, datarefs, i, dr)
 {
 dist = self_reuse_distance (dr, loop_data_size, n, loop);
 ref = (struct mem_ref *) dr->aux;
 if (ref->reuse_distance > dist)
 	ref->reuse_distance = dist;
 	ref->independent_p = true;
 }
 compute_all_dependences (datarefs, &dependences, vloops, true);
-for (i = 0; VEC_iterate (ddr_p, dependences, i, dep); i++)
+FOR_EACH_VEC_ELT (ddr_p, dependences, i, dep)
 {
 if (DDR_ARE_DEPENDENT (dep) == chrec_known)
 	continue;
 ref = (struct mem_ref *) DDR_A (dep)->aux;
 	  fprintf (dump_file, " ref %p distance %u\n",
 		   (void *) ref, ref->reuse_distance);
 }
 }
-/* Do a cost-benefit analysis to determine if prefetching is profitable
+/* Determine whether or not the trip count to ahead ratio is too small based
-for the current loop given the following parameters:
+on prefitablility consideration.
 AHEAD: the iteration ahead distance,
-EST_NITER: the estimated trip count,
+EST_NITER: the estimated trip count.  */
+static bool
+trip_count_to_ahead_ratio_too_small_p (unsigned ahead, HOST_WIDE_INT est_niter)
+{
+/* Assume trip count to ahead ratio is big enough if the trip count could not
+be estimated at compile time.  */
+if (est_niter < 0)
+return false;
+if (est_niter < (HOST_WIDE_INT) (TRIP_COUNT_TO_AHEAD_RATIO * ahead))
+{
+if (dump_file && (dump_flags & TDF_DETAILS))
+	fprintf (dump_file,
+		 "Not prefetching -- loop estimated to roll only %d times\n",
+		 (int) est_niter);
+return true;
+}
+return false;
+}
+/* Determine whether or not the number of memory references in the loop is
+reasonable based on the profitablity and compilation time considerations.
 NINSNS: estimated number of instructions in the loop,
-PREFETCH_COUNT: an estimate of the number of prefetches
 MEM_REF_COUNT: total number of memory references in the loop.  */
 static bool
-is_loop_prefetching_profitable (unsigned ahead, HOST_WIDE_INT est_niter,
+mem_ref_count_reasonable_p (unsigned ninsns, unsigned mem_ref_count)
-				unsigned ninsns, unsigned prefetch_count,
+{
-				unsigned mem_ref_count, unsigned unroll_factor)
+int insn_to_mem_ratio;
-{
-int insn_to_mem_ratio, insn_to_prefetch_ratio;
 if (mem_ref_count == 0)
+return false;
+/* Miss rate computation (is_miss_rate_acceptable) and dependence analysis
+(compute_all_dependences) have high costs based on quadratic complexity.
+To avoid huge compilation time, we give up prefetching if mem_ref_count
+is too large.  */
+if (mem_ref_count > PREFETCH_MAX_MEM_REFS_PER_LOOP)
 return false;
 /* Prefetching improves performance by overlapping cache missing
 memory accesses with CPU operations.  If the loop does not have
 enough CPU operations to overlap with memory operations, prefetching
 fprintf (dump_file,
 		 "Not prefetching -- instruction to memory reference ratio (%d) too small\n",
 		 insn_to_mem_ratio);
 return false;
 }
+return true;
+}
+/* Determine whether or not the instruction to prefetch ratio in the loop is
+too small based on the profitablity consideration.
+NINSNS: estimated number of instructions in the loop,
+PREFETCH_COUNT: an estimate of the number of prefetches,
+UNROLL_FACTOR:  the factor to unroll the loop if prefetching.  */
+static bool
+insn_to_prefetch_ratio_too_small_p (unsigned ninsns, unsigned prefetch_count,
+unsigned unroll_factor)
+{
+int insn_to_prefetch_ratio;
 /* Prefetching most likely causes performance degradation when the instruction
 to prefetch ratio is too small.  Too many prefetch instructions in a loop
 may reduce the I-cache performance.
 (unroll_factor * ninsns) is used to estimate the number of instructions in
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file,
 		 "Not prefetching -- instruction to prefetch ratio (%d) too small\n",
 		 insn_to_prefetch_ratio);
-return false;
+return true;
 }
-/* Could not do further estimation if the trip count is unknown.  Just assume
+return false;
-prefetching is profitable. Too aggressive???  */
-if (est_niter < 0)
-return true;
-if (est_niter < (HOST_WIDE_INT) (TRIP_COUNT_TO_AHEAD_RATIO * ahead))
-{
-if (dump_file && (dump_flags & TDF_DETAILS))
-	fprintf (dump_file,
-		 "Not prefetching -- loop estimated to roll only %d times\n",
-		 (int) est_niter);
-return false;
-}
-return true;
 }
 /* Issue prefetch instructions for array references in LOOP.  Returns
 true if the LOOP was unrolled.  */
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "  ignored (cold area)\n");
 return false;
 }
-/* Step 1: gather the memory references.  */
-refs = gather_memory_references (loop, &no_other_refs, &mem_ref_count);
-/* Step 2: estimate the reuse effects.  */
-prune_by_reuse (refs);
-prefetch_count = estimate_prefetch_count (refs);
-if (prefetch_count == 0)
-goto fail;
-determine_loop_nest_reuse (loop, refs, no_other_refs);
-/* Step 3: determine the ahead and unroll factor.  */
 /* FIXME: the time should be weighted by the probabilities of the blocks in
 the loop body.  */
 time = tree_num_loop_insns (loop, &eni_time_weights);
+if (time == 0)
+return false;
 ahead = (PREFETCH_LATENCY + time - 1) / time;
 est_niter = estimated_loop_iterations_int (loop, false);
+/* Prefetching is not likely to be profitable if the trip count to ahead
+ratio is too small.  */
+if (trip_count_to_ahead_ratio_too_small_p (ahead, est_niter))
+return false;
 ninsns = tree_num_loop_insns (loop, &eni_size_weights);
+/* Step 1: gather the memory references.  */
+refs = gather_memory_references (loop, &no_other_refs, &mem_ref_count);
+/* Give up prefetching if the number of memory references in the
+loop is not reasonable based on profitablity and compilation time
+considerations.  */
+if (!mem_ref_count_reasonable_p (ninsns, mem_ref_count))
+goto fail;
+/* Step 2: estimate the reuse effects.  */
+prune_by_reuse (refs);
+if (nothing_to_prefetch_p (refs))
+goto fail;
+determine_loop_nest_reuse (loop, refs, no_other_refs);
+/* Step 3: determine unroll factor.  */
 unroll_factor = determine_unroll_factor (loop, refs, ninsns, &desc,
 					   est_niter);
+/* Estimate prefetch count for the unrolled loop.  */
+prefetch_count = estimate_prefetch_count (refs, unroll_factor);
+if (prefetch_count == 0)
+goto fail;
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, "Ahead %d, unroll factor %d, trip count "
 	     HOST_WIDE_INT_PRINT_DEC "\n"
 	     "insn count %d, mem ref count %d, prefetch count %d\n",
 	     ahead, unroll_factor, est_niter,
 	     ninsns, mem_ref_count, prefetch_count);
-if (!is_loop_prefetching_profitable (ahead, est_niter, ninsns, prefetch_count,
+/* Prefetching is not likely to be profitable if the instruction to prefetch
-				       mem_ref_count, unroll_factor))
+ratio is too small.  */
+if (insn_to_prefetch_ratio_too_small_p (ninsns, prefetch_count,
+					  unroll_factor))
 goto fail;
 mark_nontemporal_stores (loop, refs);
 /* Step 4: what to prefetch?  */
 initialize_original_copy_tables ();
 if (!built_in_decls[BUILT_IN_PREFETCH])
 {
-tree type = build_function_type (void_type_node,
+tree type = build_function_type_list (void_type_node,
-				       tree_cons (NULL_TREE,
+					    const_ptr_type_node, NULL_TREE);
-						  const_ptr_type_node,
-						  NULL_TREE));
 tree decl = add_builtin_function ("__builtin_prefetch", type,
 					BUILT_IN_PREFETCH, BUILT_IN_NORMAL,
 					NULL, NULL_TREE);
 DECL_IS_NOVOPS (decl) = true;
 built_in_decls[BUILT_IN_PREFETCH] = decl;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-loop-prefetch.c @ 67:f6334be47118