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

comparison gcc/tree-ssa-loop-prefetch.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Array prefetching.
-Copyright (C) 2005-2018 Free Software Foundation, Inc.
+Copyright (C) 2005-2020 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 #include "tree-ssa-loop.h"
 #include "ssa.h"
 #include "tree-into-ssa.h"
 #include "cfgloop.h"
 #include "tree-scalar-evolution.h"
-#include "params.h"
 #include "langhooks.h"
 #include "tree-inline.h"
 #include "tree-data-ref.h"
 #include "diagnostic-core.h"
 #include "dbgcnt.h"
 /* The size of the block loaded by a single prefetch.  Usually, this is
 the same as cache line size (at the moment, we only consider one level
 of cache hierarchy).  */
 #ifndef PREFETCH_BLOCK
-#define PREFETCH_BLOCK L1_CACHE_LINE_SIZE
+#define PREFETCH_BLOCK param_l1_cache_line_size
 #endif
 /* Do we have a forward hardware sequential prefetching?  */
 #ifndef HAVE_FORWARD_PREFETCH
 #ifndef ACCEPTABLE_MISS_RATE
 #define ACCEPTABLE_MISS_RATE 50
 #endif
-#define L1_CACHE_SIZE_BYTES ((unsigned) (L1_CACHE_SIZE * 1024))
+#define L1_CACHE_SIZE_BYTES ((unsigned) (param_l1_cache_size * 1024))
-#define L2_CACHE_SIZE_BYTES ((unsigned) (L2_CACHE_SIZE * 1024))
+#define L2_CACHE_SIZE_BYTES ((unsigned) (param_l2_cache_size * 1024))
 /* We consider a memory access nontemporal if it is not reused sooner than
 after L2_CACHE_SIZE_BYTES of memory are accessed.  However, we ignore
 accesses closer than L1_CACHE_SIZE_BYTES / NONTEMPORAL_FRACTION,
 so that we use nontemporal prefetches e.g. if single memory location
 /* A structure used to pass arguments to idx_analyze_ref.  */
 struct ar_data
 {
-struct loop *loop;			/* Loop of the reference.  */
+class loop *loop;			/* Loop of the reference.  */
 gimple *stmt;				/* Statement of the reference.  */
 tree *step;				/* Step of the memory reference.  */
 HOST_WIDE_INT *delta;			/* Offset of the memory reference.  */
 };
 STEP are integer constants and iter is number of iterations of LOOP.  The
 reference occurs in statement STMT.  Strips nonaddressable component
 references from REF_P.  */
 static bool
-analyze_ref (struct loop *loop, tree *ref_p, tree *base,
+analyze_ref (class loop *loop, tree *ref_p, tree *base,
 	     tree *step, HOST_WIDE_INT *delta,
 	     gimple *stmt)
 {
 struct ar_data ar_data;
 tree off;
 /* Record a memory reference REF to the list REFS.  The reference occurs in
 LOOP in statement STMT and it is write if WRITE_P.  Returns true if the
 reference was recorded, false otherwise.  */
 static bool
-gather_memory_references_ref (struct loop *loop, struct mem_ref_group **refs,
+gather_memory_references_ref (class loop *loop, struct mem_ref_group **refs,
 			      tree ref, bool write_p, gimple *stmt)
 {
 tree base, step;
 HOST_WIDE_INT delta;
 struct mem_ref_group *agrp;
 /* Record the suitable memory references in LOOP.  NO_OTHER_REFS is set to
 true if there are no other memory references inside the loop.  */
 static struct mem_ref_group *
-gather_memory_references (struct loop *loop, bool *no_other_refs, unsigned *ref_count)
+gather_memory_references (class loop *loop, bool *no_other_refs, unsigned *ref_count)
 {
 basic_block *body = get_loop_body_in_dom_order (loop);
 basic_block bb;
 unsigned i;
 gimple_stmt_iterator bsi;
 static bool
 should_issue_prefetch_p (struct mem_ref *ref)
 {
 /* Do we want to issue prefetches for non-constant strides?  */
-if (!cst_and_fits_in_hwi (ref->group->step) && PREFETCH_DYNAMIC_STRIDES == 0)
+if (!cst_and_fits_in_hwi (ref->group->step)
+&& param_prefetch_dynamic_strides == 0)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file,
 		 "Skipping non-constant step for reference %u:%u\n",
 		 ref->group->uid, ref->uid);
 prefetch hints for a range of strides.  Make sure we don't issue
 prefetches for such cases if the stride is within this particular
 range.  */
 if (cst_and_fits_in_hwi (ref->group->step)
 && abs_hwi (int_cst_value (ref->group->step))
-	  < (HOST_WIDE_INT) PREFETCH_MINIMUM_STRIDE)
+	  < (HOST_WIDE_INT) param_prefetch_minimum_stride)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file,
 		 "Step for reference %u:%u (" HOST_WIDE_INT_PRINT_DEC
 		 ") is less than the mininum required stride of %d\n",
 		 ref->group->uid, ref->uid, int_cst_value (ref->group->step),
-		 PREFETCH_MINIMUM_STRIDE);
+		 param_prefetch_minimum_stride);
 return false;
 }
 /* For now do not issue prefetches for only first few of the
 iterations.  */
 unsigned remaining_prefetch_slots, n_prefetches, prefetch_slots;
 unsigned slots_per_prefetch;
 struct mem_ref *ref;
 bool any = false;
-/* At most SIMULTANEOUS_PREFETCHES should be running at the same time.  */
+/* At most param_simultaneous_prefetches should be running
-remaining_prefetch_slots = SIMULTANEOUS_PREFETCHES;
+at the same time.  */
+remaining_prefetch_slots = param_simultaneous_prefetches;
 /* The prefetch will run for AHEAD iterations of the original loop, i.e.,
 AHEAD / UNROLL_FACTOR iterations of the unrolled loop.  In each iteration,
 it will need a prefetch slot.  */
 slots_per_prefetch = (ahead + unroll_factor / 2) / unroll_factor;
 }
 /* Issue a memory fence instruction after LOOP.  */
 static void
-emit_mfence_after_loop (struct loop *loop)
+emit_mfence_after_loop (class loop *loop)
 {
 vec<edge> exits = get_loop_exit_edges (loop);
 edge exit;
 gcall *call;
 gimple_stmt_iterator bsi;
 }
 /* Returns true if we can use storent in loop, false otherwise.  */
 static bool
-may_use_storent_in_loop_p (struct loop *loop)
+may_use_storent_in_loop_p (class loop *loop)
 {
 bool ret = true;
 if (loop->inner != NULL)
 return false;
 /* Marks nontemporal stores in LOOP.  GROUPS contains the description of memory
 references in the loop.  */
 static void
-mark_nontemporal_stores (struct loop *loop, struct mem_ref_group *groups)
+mark_nontemporal_stores (class loop *loop, struct mem_ref_group *groups)
 {
 struct mem_ref *ref;
 bool any = false;
 if (!may_use_storent_in_loop_p (loop))
 /* Determines whether we can profitably unroll LOOP FACTOR times, and if
 this is the case, fill in DESC by the description of number of
 iterations.  */
 static bool
-should_unroll_loop_p (struct loop *loop, struct tree_niter_desc *desc,
+should_unroll_loop_p (class loop *loop, class tree_niter_desc *desc,
 		      unsigned factor)
 {
 if (!can_unroll_loop_p (loop, factor, desc))
 return false;
 number of iterations of LOOP is stored to DESC.  NINSNS is the number of
 insns of the LOOP.  EST_NITER is the estimated number of iterations of
 the loop, or -1 if no estimate is available.  */
 static unsigned
-determine_unroll_factor (struct loop *loop, struct mem_ref_group *refs,
+determine_unroll_factor (class loop *loop, struct mem_ref_group *refs,
-			 unsigned ninsns, struct tree_niter_desc *desc,
+			 unsigned ninsns, class tree_niter_desc *desc,
 			 HOST_WIDE_INT est_niter)
 {
 unsigned upper_bound;
 unsigned nfactor, factor, mod_constraint;
 struct mem_ref_group *agp;
 from unrolling them enough to make exactly one cache line covered by each
 iteration.  Also, the goal of PARAM_MAX_UNROLL_TIMES is to prevent
 us from unrolling the loops too many times in cases where we only expect
 gains from better scheduling and decreasing loop overhead, which is not
 the case here.  */
-upper_bound = PARAM_VALUE (PARAM_MAX_UNROLLED_INSNS) / ninsns;
+upper_bound = param_max_unrolled_insns / ninsns;
 /* If we unrolled the loop more times than it iterates, the unrolled version
 of the loop would be never entered.  */
 if (est_niter >= 0 && est_niter < (HOST_WIDE_INT) upper_bound)
 upper_bound = est_niter;
 	/* If several iterations access the same cache line, use the size of
 	   the line divided by this number.  Otherwise, a cache line is
 	   accessed in each iteration.  TODO -- in the latter case, we should
 	   take the size of the reference into account, rounding it up on cache
 	   line size multiple.  */
-	volume += L1_CACHE_LINE_SIZE / ref->prefetch_mod;
+	volume += param_l1_cache_line_size / ref->prefetch_mod;
 }
 return volume;
 }
 /* Returns the volume of memory references accessed across VEC iterations of
 at the position corresponding to the loop of the step.  N is the depth
 of the considered loop nest, and, LOOP is its innermost loop.  */
 static void
 add_subscript_strides (tree access_fn, unsigned stride,
-		       HOST_WIDE_INT *strides, unsigned n, struct loop *loop)
+		       HOST_WIDE_INT *strides, unsigned n, class loop *loop)
 {
-struct loop *aloop;
+class loop *aloop;
 tree step;
 HOST_WIDE_INT astep;
 unsigned min_depth = loop_depth (loop) - n;
 while (TREE_CODE (access_fn) == POLYNOMIAL_CHREC)
 	continue;
 if (tree_fits_shwi_p (step))
 	astep = tree_to_shwi (step);
 else
-	astep = L1_CACHE_LINE_SIZE;
+	astep = param_l1_cache_line_size;
 strides[n - 1 - loop_depth (loop) + loop_depth (aloop)] += astep * stride;
 }
 }
 loops, and LOOP_SIZES contains the volumes of accesses in each of the
 loops.  LOOP is the innermost loop of the current loop nest.  */
 static unsigned
 self_reuse_distance (data_reference_p dr, unsigned *loop_sizes, unsigned n,
-		     struct loop *loop)
+		     class loop *loop)
 {
 tree stride, access_fn;
 HOST_WIDE_INT *strides, astride;
 vec<tree> access_fns;
 tree ref = DR_REF (dr);
 	{
 	  stride = TYPE_SIZE_UNIT (TREE_TYPE (ref));
 	  if (tree_fits_uhwi_p (stride))
 	    astride = tree_to_uhwi (stride);
 	  else
-	    astride = L1_CACHE_LINE_SIZE;
+	    astride = param_l1_cache_line_size;
 	  ref = TREE_OPERAND (ref, 0);
 	}
 else
 	astride = 1;
 {
 unsigned HOST_WIDE_INT s;
 s = strides[i] < 0 ?  -strides[i] : strides[i];
-if (s < (unsigned) L1_CACHE_LINE_SIZE
+if (s < (unsigned) param_l1_cache_line_size
 	  && (loop_sizes[i]
 	      > (unsigned) (L1_CACHE_SIZE_BYTES / NONTEMPORAL_FRACTION)))
 	{
 	  ret = loop_sizes[i];
 	  break;
 /* Determines the distance till the first reuse of each reference in REFS
 in the loop nest of LOOP.  NO_OTHER_REFS is true if there are no other
 memory references in the loop.  Return false if the analysis fails.  */
 static bool
-determine_loop_nest_reuse (struct loop *loop, struct mem_ref_group *refs,
+determine_loop_nest_reuse (class loop *loop, struct mem_ref_group *refs,
 			   bool no_other_refs)
 {
-struct loop *nest, *aloop;
+class loop *nest, *aloop;
 vec<data_reference_p> datarefs = vNULL;
 vec<ddr_p> dependences = vNULL;
 struct mem_ref_group *gr;
 struct mem_ref *ref, *refb;
 auto_vec<loop_p> vloops;
 TODO: Implement a more precise computation by estimating the time
 for each CPU or memory op in the loop. Time estimates for memory ops
 should account for cache misses.  */
 insn_to_mem_ratio = ninsns / mem_ref_count;
-if (insn_to_mem_ratio < PREFETCH_MIN_INSN_TO_MEM_RATIO)
+if (insn_to_mem_ratio < param_prefetch_min_insn_to_mem_ratio)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file,
 		 "Not prefetching -- instruction to memory reference ratio (%d) too small\n",
 		 insn_to_mem_ratio);
 loop will usually be significantly smaller than the number of insns of the
 original loop * unroll_factor (at least the induction variable increases
 and the exit branches will get eliminated), so it might be better to use
 tree_estimate_loop_size + estimated_unrolled_size.  */
 insn_to_prefetch_ratio = (unroll_factor * ninsns) / prefetch_count;
-if (insn_to_prefetch_ratio < MIN_INSN_TO_PREFETCH_RATIO)
+if (insn_to_prefetch_ratio < param_min_insn_to_prefetch_ratio)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file,
 		 "Not prefetching -- instruction to prefetch ratio (%d) too small\n",
 		 insn_to_prefetch_ratio);
 /* Issue prefetch instructions for array references in LOOP.  Returns
 true if the LOOP was unrolled.  */
 static bool
-loop_prefetch_arrays (struct loop *loop)
+loop_prefetch_arrays (class loop *loop)
 {
 struct mem_ref_group *refs;
 unsigned ahead, ninsns, time, unroll_factor;
 HOST_WIDE_INT est_niter;
-struct tree_niter_desc desc;
+class tree_niter_desc desc;
 bool unrolled = false, no_other_refs;
 unsigned prefetch_count;
 unsigned mem_ref_count;
 if (optimize_loop_nest_for_size_p (loop))
 the loop body.  */
 time = tree_num_loop_insns (loop, &eni_time_weights);
 if (time == 0)
 return false;
-ahead = (PREFETCH_LATENCY + time - 1) / time;
+ahead = (param_prefetch_latency + time - 1) / time;
 est_niter = estimated_stmt_executions_int (loop);
 if (est_niter == -1)
 est_niter = likely_max_stmt_executions_int (loop);
 /* Prefetching is not likely to be profitable if the trip count to ahead
 /* Issue prefetch instructions for array references in loops.  */
 unsigned int
 tree_ssa_prefetch_arrays (void)
 {
-struct loop *loop;
+class loop *loop;
 bool unrolled = false;
 int todo_flags = 0;
 if (!targetm.have_prefetch ()
 /* It is possible to ask compiler for say -mtune=i486 -march=pentium4.
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "Prefetching parameters:\n");
 fprintf (dump_file, "    simultaneous prefetches: %d\n",
-	       SIMULTANEOUS_PREFETCHES);
+	       param_simultaneous_prefetches);
-fprintf (dump_file, "    prefetch latency: %d\n", PREFETCH_LATENCY);
+fprintf (dump_file, "    prefetch latency: %d\n", param_prefetch_latency);
 fprintf (dump_file, "    prefetch block size: %d\n", PREFETCH_BLOCK);
 fprintf (dump_file, "    L1 cache size: %d lines, %d kB\n",
-	       L1_CACHE_SIZE_BYTES / L1_CACHE_LINE_SIZE, L1_CACHE_SIZE);
+	       L1_CACHE_SIZE_BYTES / param_l1_cache_line_size,
-fprintf (dump_file, "    L1 cache line size: %d\n", L1_CACHE_LINE_SIZE);
+	       param_l1_cache_size);
-fprintf (dump_file, "    L2 cache size: %d kB\n", L2_CACHE_SIZE);
+fprintf (dump_file, "    L1 cache line size: %d\n",
+	       param_l1_cache_line_size);
+fprintf (dump_file, "    L2 cache size: %d kB\n", param_l2_cache_size);
 fprintf (dump_file, "    min insn-to-prefetch ratio: %d \n",
-	       MIN_INSN_TO_PREFETCH_RATIO);
+	       param_min_insn_to_prefetch_ratio);
 fprintf (dump_file, "    min insn-to-mem ratio: %d \n",
-	       PREFETCH_MIN_INSN_TO_MEM_RATIO);
+	       param_prefetch_min_insn_to_mem_ratio);
 fprintf (dump_file, "\n");
 }
 initialize_original_copy_tables ();

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-loop-prefetch.c @ 145:1830386684a0