Subversion Repositories openrisc

/* Array prefetching.

   Copyright (C) 2005, 2007, 2008 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

Free Software Foundation; either version 3, or (at your option) any

later version.

GCC is distributed in the hope that it will be useful, but WITHOUT

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "rtl.h"

#include "tm_p.h"

#include "hard-reg-set.h"

#include "basic-block.h"

#include "output.h"

#include "diagnostic.h"

#include "tree-flow.h"

#include "tree-dump.h"

#include "timevar.h"

#include "cfgloop.h"

#include "varray.h"

#include "expr.h"

#include "tree-pass.h"

#include "ggc.h"

#include "insn-config.h"

#include "recog.h"

#include "hashtab.h"

#include "tree-chrec.h"

#include "tree-scalar-evolution.h"

#include "toplev.h"

#include "params.h"

#include "langhooks.h"

#include "tree-inline.h"

#include "tree-data-ref.h"

#include "optabs.h"

/* This pass inserts prefetch instructions to optimize cache usage during

   accesses to arrays in loops.  It processes loops sequentially and:

   1) Gathers all memory references in the single loop.

   2) For each of the references it decides when it is profitable to prefetch

      it.  To do it, we evaluate the reuse among the accesses, and determines

      two values: PREFETCH_BEFORE (meaning that it only makes sense to do

      prefetching in the first PREFETCH_BEFORE iterations of the loop) and

      PREFETCH_MOD (meaning that it only makes sense to prefetch in the

      iterations of the loop that are zero modulo PREFETCH_MOD).  For example

      (assuming cache line size is 64 bytes, char has size 1 byte and there

      is no hardware sequential prefetch):

      char *a;

      for (i = 0; i < max; i++)

        {

          a[255] = ...;         (0)

          a[i] = ...;           (1)

          a[i + 64] = ...;      (2)

          a[16*i] = ...;        (3)

          a[187*i] = ...;       (4)

          a[187*i + 50] = ...;  (5)

        }

       (0) obviously has PREFETCH_BEFORE 1

       (1) has PREFETCH_BEFORE 64, since (2) accesses the same memory

           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

           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

      to determine the temporality of the issued prefetch instruction.

   3) We determine how much ahead we need to prefetch.  The number of

      iterations needed is time to fetch / time spent in one iteration of

      the loop.  The problem is that we do not know either of these values,

      so we just make a heuristic guess based on a magic (possibly)

      target-specific constant and size of the loop.

   4) Determine which of the references we prefetch.  We take into account

      that there is a maximum number of simultaneous prefetches (provided

      by machine description).  We prefetch as many prefetches as possible

      while still within this bound (starting with those with lowest

      prefetch_mod, since they are responsible for most of the cache

      misses).

   5) We unroll and peel loops so that we are able to satisfy PREFETCH_MOD

      and PREFETCH_BEFORE requirements (within some bounds), and to avoid

      prefetching nonaccessed memory.

      TODO -- actually implement peeling.

   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

   to determine if prefetching is profitable for a given loop. The cost

   model has two heuristcs:

   1. A heuristic that determines whether the given loop has enough CPU

      ops that can be overlapped with cache missing memory ops.

      If not, the loop won't benefit from prefetching. This is implemented

      by requirung the ratio between the instruction count and the mem ref

      count to be above a certain 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

      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:

      -- write and use more general reuse analysis (that could be also used

         in other cache aimed loop optimizations)

      -- make it behave sanely together with the prefetches given by user

         (now we just ignore them; at the very least we should avoid

         optimizing loops in that user put his own prefetches)

      -- we assume cache line size alignment of arrays; this could be

         improved.  */

/* Magic constants follow.  These should be replaced by machine specific

   numbers.  */

/* True if write can be prefetched by a read prefetch.  */

#ifndef WRITE_CAN_USE_READ_PREFETCH

#define WRITE_CAN_USE_READ_PREFETCH 1

#endif

/* True if read can be prefetched by a write prefetch. */

#ifndef READ_CAN_USE_WRITE_PREFETCH

#define READ_CAN_USE_WRITE_PREFETCH 0

#endif

/* 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

#endif

/* Do we have a forward hardware sequential prefetching?  */

#ifndef HAVE_FORWARD_PREFETCH

#define HAVE_FORWARD_PREFETCH 0

#endif

/* Do we have a backward hardware sequential prefetching?  */

#ifndef HAVE_BACKWARD_PREFETCH

#define HAVE_BACKWARD_PREFETCH 0

#endif

/* In some cases we are only able to determine that there is a certain

   probability that the two accesses hit the same cache line.  In this

   case, we issue the prefetches for both of them if this probability

   is less then (1000 - ACCEPTABLE_MISS_RATE) per thousand.  */

#ifndef ACCEPTABLE_MISS_RATE

#define ACCEPTABLE_MISS_RATE 50

#endif

#ifndef HAVE_prefetch

#define HAVE_prefetch 0

#endif

#define L1_CACHE_SIZE_BYTES ((unsigned) (L1_CACHE_SIZE * 1024))

#define L2_CACHE_SIZE_BYTES ((unsigned) (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

   is accessed several times in a single iteration of the loop.  */

#define NONTEMPORAL_FRACTION 16

/* In case we have to emit a memory fence instruction after the loop that

   uses nontemporal stores, this defines the builtin to use.  */

#ifndef FENCE_FOLLOWING_MOVNT

#define FENCE_FOLLOWING_MOVNT NULL_TREE

#endif

/* The group of references between that reuse may occur.  */

struct mem_ref_group

{

  tree base;                    /* Base of the reference.  */

  HOST_WIDE_INT step;           /* Step of the reference.  */

  struct mem_ref *refs;         /* References in the group.  */

  struct mem_ref_group *next;   /* Next group of references.  */

};

/* Assigned to PREFETCH_BEFORE when all iterations are to be prefetched.  */

#define PREFETCH_ALL            (~(unsigned HOST_WIDE_INT) 0)

/* The memory reference.  */

struct mem_ref

{

  gimple stmt;                  /* Statement in that the reference appears.  */

  tree mem;                     /* The reference.  */

  HOST_WIDE_INT delta;          /* Constant offset of the reference.  */

  struct mem_ref_group *group;  /* The group of references it belongs to.  */

  unsigned HOST_WIDE_INT prefetch_mod;

                                /* Prefetch only each PREFETCH_MOD-th

                                   iteration.  */

  unsigned HOST_WIDE_INT prefetch_before;

                                /* Prefetch only first PREFETCH_BEFORE

                                   iterations.  */

  unsigned reuse_distance;      /* The amount of data accessed before the first

                                   reuse of this value.  */

  struct mem_ref *next;         /* The next reference in the group.  */

  unsigned write_p : 1;         /* Is it a write?  */

  unsigned independent_p : 1;   /* True if the reference is independent on

                                   all other references inside the loop.  */

  unsigned issue_prefetch_p : 1;        /* Should we really issue the prefetch?  */

  unsigned storent_p : 1;       /* True if we changed the store to a

                                   nontemporal one.  */

};

/* Dumps information about reference REF to FILE.  */

static void

dump_mem_ref (FILE *file, struct mem_ref *ref)

{

  fprintf (file, "Reference %p:\n", (void *) ref);

  fprintf (file, "  group %p (base ", (void *) ref->group);

  print_generic_expr (file, ref->group->base, TDF_SLIM);

  fprintf (file, ", step ");

  fprintf (file, HOST_WIDE_INT_PRINT_DEC, ref->group->step);

  fprintf (file, ")\n");

  fprintf (file, "  delta ");

  fprintf (file, HOST_WIDE_INT_PRINT_DEC, ref->delta);

  fprintf (file, "\n");

  fprintf (file, "  %s\n", ref->write_p ? "write" : "read");

  fprintf (file, "\n");

}

/* Finds a group with BASE and STEP in GROUPS, or creates one if it does not

   exist.  */

static struct mem_ref_group *

find_or_create_group (struct mem_ref_group **groups, tree base,

                      HOST_WIDE_INT step)

{

  struct mem_ref_group *group;

  for (; *groups; groups = &(*groups)->next)

    {

      if ((*groups)->step == step

          && operand_equal_p ((*groups)->base, base, 0))

        return *groups;

      /* Keep the list of groups sorted by decreasing step.  */

      if ((*groups)->step < step)

        break;

    }

  group = XNEW (struct mem_ref_group);

  group->base = base;

  group->step = step;

  group->refs = NULL;

  group->next = *groups;

  *groups = group;

  return group;

}

/* Records a memory reference MEM in GROUP with offset DELTA and write status

   WRITE_P.  The reference occurs in statement STMT.  */

static void

record_ref (struct mem_ref_group *group, gimple stmt, tree mem,

            HOST_WIDE_INT delta, bool write_p)

{

  struct mem_ref **aref;

  /* Do not record the same address twice.  */

  for (aref = &group->refs; *aref; aref = &(*aref)->next)

    {

      /* It does not have to be possible for write reference to reuse the read

         prefetch, or vice versa.  */

      if (!WRITE_CAN_USE_READ_PREFETCH

          && write_p

          && !(*aref)->write_p)

        continue;

      if (!READ_CAN_USE_WRITE_PREFETCH

          && !write_p

          && (*aref)->write_p)

        continue;

      if ((*aref)->delta == delta)

        return;

    }

  (*aref) = XNEW (struct mem_ref);

  (*aref)->stmt = stmt;

  (*aref)->mem = mem;

  (*aref)->delta = delta;

  (*aref)->write_p = write_p;

  (*aref)->prefetch_before = PREFETCH_ALL;

  (*aref)->prefetch_mod = 1;

  (*aref)->reuse_distance = 0;

  (*aref)->issue_prefetch_p = false;

  (*aref)->group = group;

  (*aref)->next = NULL;

  (*aref)->independent_p = false;

  (*aref)->storent_p = false;

  if (dump_file && (dump_flags & TDF_DETAILS))

    dump_mem_ref (dump_file, *aref);

}

/* Release memory references in GROUPS.  */

static void

release_mem_refs (struct mem_ref_group *groups)

{

  struct mem_ref_group *next_g;

  struct mem_ref *ref, *next_r;

  for (; groups; groups = next_g)

    {

      next_g = groups->next;

      for (ref = groups->refs; ref; ref = next_r)

        {

          next_r = ref->next;

          free (ref);

        }

      free (groups);

    }

}

/* A structure used to pass arguments to idx_analyze_ref.  */

struct ar_data

{

  struct loop *loop;                    /* Loop of the reference.  */

  gimple stmt;                          /* Statement of the reference.  */

  HOST_WIDE_INT *step;                  /* Step of the memory reference.  */

  HOST_WIDE_INT *delta;                 /* Offset of the memory reference.  */

};

/* Analyzes a single INDEX of a memory reference to obtain information

   described at analyze_ref.  Callback for for_each_index.  */

static bool

idx_analyze_ref (tree base, tree *index, void *data)

{

  struct ar_data *ar_data = (struct ar_data *) data;

  tree ibase, step, stepsize;

  HOST_WIDE_INT istep, 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, false))

    return false;

  ibase = iv.base;

  step = iv.step;

  if (!cst_and_fits_in_hwi (step))

    return false;

  istep = int_cst_value (step);

  if (TREE_CODE (ibase) == POINTER_PLUS_EXPR

      && cst_and_fits_in_hwi (TREE_OPERAND (ibase, 1)))

    {

      idelta = int_cst_value (TREE_OPERAND (ibase, 1));

      ibase = TREE_OPERAND (ibase, 0);

    }

  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);

      istep *= imult;

      idelta *= imult;

    }

  *ar_data->step += istep;

  *ar_data->delta += idelta;

  *index = ibase;

  return true;

}

/* Tries to express REF_P in shape &BASE + STEP * iter + DELTA, where DELTA and

   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,

             HOST_WIDE_INT *step, HOST_WIDE_INT *delta,

             gimple stmt)

{

  struct ar_data ar_data;

  tree off;

  HOST_WIDE_INT bit_offset;

  tree ref = *ref_p;

  *step = 0;

  *delta = 0;

  /* First strip off the component references.  Ignore bitfields.  */

  if (TREE_CODE (ref) == COMPONENT_REF

      && DECL_NONADDRESSABLE_P (TREE_OPERAND (ref, 1)))

    ref = TREE_OPERAND (ref, 0);

  *ref_p = ref;

  for (; TREE_CODE (ref) == COMPONENT_REF; ref = TREE_OPERAND (ref, 0))

    {

      off = DECL_FIELD_BIT_OFFSET (TREE_OPERAND (ref, 1));

      bit_offset = TREE_INT_CST_LOW (off);

      gcc_assert (bit_offset % BITS_PER_UNIT == 0);

      *delta += bit_offset / BITS_PER_UNIT;

    }

  *base = unshare_expr (ref);

  ar_data.loop = loop;

  ar_data.stmt = stmt;

  ar_data.step = step;

  ar_data.delta = delta;

  return for_each_index (base, idx_analyze_ref, &ar_data);

}

/* 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,

                              tree ref, bool write_p, gimple stmt)

{

  tree base;

  HOST_WIDE_INT step, delta;

  struct mem_ref_group *agrp;

  if (get_base_address (ref) == NULL)

    return false;

  if (!analyze_ref (loop, &ref, &base, &step, &delta, stmt))

    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);

  record_ref (agrp, stmt, ref, delta, write_p);

  return true;

}

/* 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)

{

  basic_block *body = get_loop_body_in_dom_order (loop);

  basic_block bb;

  unsigned i;

  gimple_stmt_iterator bsi;

  gimple stmt;

  tree lhs, rhs;

  struct mem_ref_group *refs = NULL;

  *no_other_refs = true;

  *ref_count = 0;

  /* Scan the loop body in order, so that the former references precede the

     later ones.  */

  for (i = 0; i < loop->num_nodes; i++)

    {

      bb = body[i];

      if (bb->loop_father != loop)

        continue;

      for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))

        {

          stmt = gsi_stmt (bsi);

          if (gimple_code (stmt) != GIMPLE_ASSIGN)

            {

              if (gimple_vuse (stmt)

                  || (is_gimple_call (stmt)

                      && !(gimple_call_flags (stmt) & ECF_CONST)))

                *no_other_refs = false;

              continue;

            }

          lhs = gimple_assign_lhs (stmt);

          rhs = gimple_assign_rhs1 (stmt);

          if (REFERENCE_CLASS_P (rhs))

            {

            *no_other_refs &= gather_memory_references_ref (loop, &refs,

                                                            rhs, false, stmt);

            *ref_count += 1;

            }

          if (REFERENCE_CLASS_P (lhs))

            {

            *no_other_refs &= gather_memory_references_ref (loop, &refs,

                                                            lhs, true, stmt);

            *ref_count += 1;

            }

        }

    }

  free (body);

  return refs;

}

/* Prune the prefetch candidate REF using the self-reuse.  */

static void

prune_ref_by_self_reuse (struct mem_ref *ref)

{

  HOST_WIDE_INT step = ref->group->step;

  bool backward = step < 0;

  if (step == 0)

    {

      /* Prefetch references to invariant address just once.  */

      ref->prefetch_before = 1;

      return;

    }

  if (backward)

    step = -step;

  if (step > PREFETCH_BLOCK)

    return;

  if ((backward && HAVE_BACKWARD_PREFETCH)

      || (!backward && HAVE_FORWARD_PREFETCH))

    {

      ref->prefetch_before = 1;

      return;

    }

  ref->prefetch_mod = PREFETCH_BLOCK / step;

}

/* Divides X by BY, rounding down.  */

static HOST_WIDE_INT

ddown (HOST_WIDE_INT x, unsigned HOST_WIDE_INT by)

{

  gcc_assert (by > 0);

  if (x >= 0)

    return x / by;

  else

    return (x + by - 1) / by;

}

/* 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

   distinct iterations after which the pattern repeats itself.

   ALIGN_UNIT is the unit of alignment in bytes.  */

static int

compute_miss_rate (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 address1, address2, cache_line1, cache_line2;

  total_positions = 0;

  miss_positions = 0;

  /* Iterate through all possible alignments of the first

     memory reference within its cache line.  */

  for (align = 0; align < cache_line_size; align += align_unit)

    /* Iterate through all distinct iterations.  */

    for (iter = 0; iter < distinct_iters; iter++)

      {

        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_rate = 1000 * miss_positions / total_positions;

  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.  */

static void

prune_ref_by_group_reuse (struct mem_ref *ref, struct mem_ref *by,

                          bool by_is_before)

{

  HOST_WIDE_INT step = ref->group->step;

  bool backward = step < 0;

  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;

  if (delta == 0)

    {

      /* If the references has the same address, only prefetch the

         former.  */

      if (by_is_before)

        ref->prefetch_before = 0;

      return;

    }

  if (!step)

    {

      /* If the reference addresses are invariant and fall into the

         same cache line, prefetch just the first one.  */

      if (!by_is_before)

        return;

      if (ddown (ref->delta, PREFETCH_BLOCK)

          != ddown (by->delta, PREFETCH_BLOCK))

        return;

      ref->prefetch_before = 0;

      return;

    }

  /* Only prune the reference that is behind in the array.  */

  if (backward)

    {

      if (delta > 0)

        return;

      /* Transform the data so that we may assume that the accesses

         are forward.  */

      delta = - delta;

      step = -step;

      delta_r = PREFETCH_BLOCK - 1 - delta_r;

      delta_b = PREFETCH_BLOCK - 1 - delta_b;

    }

  else

    {

      if (delta < 0)

        return;

    }

  /* Check whether the two references are likely to hit the same cache

     line, and how distant the iterations in that it occurs are from

     each other.  */

  if (step <= PREFETCH_BLOCK)

    {

      /* The accesses are sure to meet.  Let us check when.  */

      hit_from = ddown (delta_b, PREFETCH_BLOCK) * PREFETCH_BLOCK;

      prefetch_before = (hit_from - delta_r + step - 1) / step;

      if (prefetch_before < ref->prefetch_before)

        ref->prefetch_before = prefetch_before;

      return;

    }

  /* A more complicated case with step > prefetch_block.  First reduce

     the ratio between the step and the cache line size to its simplest

     terms.  The resulting denominator will then represent the number of

     distinct iterations after which each address will go back to its

     initial location within the cache line.  This computation assumes

     that PREFETCH_BLOCK is a power of two.  */

  prefetch_block = PREFETCH_BLOCK;

  reduced_prefetch_block = prefetch_block;

  reduced_step = step;

  while ((reduced_step & 1) == 0

         && reduced_prefetch_block > 1)

    {

      reduced_step >>= 1;

      reduced_prefetch_block >>= 1;

    }

  prefetch_before = delta / step;

  delta %= step;

  ref_type = TREE_TYPE (ref->mem);