Functions
static isl_union_set *	scop_get_domains ()
static isl_union_map *	scop_get_dependences ()
static isl_basic_map *	getTileMap ()
static isl_union_map *	getScheduleForBand ()
static isl_map *	getPrevectorMap (isl_ctx *ctx, int DimToVectorize, int ScheduleDimensions, int VectorWidth)
static isl_union_map *	getScheduleForBandList ()
static isl_union_map *	getScheduleMap ()
static int	getSingleMap ()
static void	apply_schedule_map_to_scop ()
bool	optimize_isl ()

Variables
static bool	DisableTiling = false
static bool	EnablePollyVector = false
static const int	CONSTANT_BOUND = 20

Function Documentation

static void apply_schedule_map_to_scop ( )

static

References scop::bbs, poly_bb::domain, getSingleMap(), and poly_bb::transformed.

Referenced by optimize_isl().

static isl_map* getPrevectorMap	(	isl_ctx *	ctx,
		int	DimToVectorize,
		int	ScheduleDimensions,
		int	VectorWidth
	)

static

Create a map that pre-vectorizes one scheduling dimension.
  
   getPrevectorMap creates a map that maps each input dimension to the same
   output dimension, except for the dimension DimToVectorize. DimToVectorize is
   strip mined by 'VectorWidth' and the newly created point loop of
   DimToVectorize is moved to the innermost level.
  
   Example (DimToVectorize=0, ScheduleDimensions=2, VectorWidth=4):
  
   | Before transformation
   |
   | A[i,j] -> [i,j]
   |
   | for (i = 0; i < 128; i++)
   |    for (j = 0; j < 128; j++)
   |      A(i,j);
  
     Prevector map:
     [i,j] -> [it,j,ip] : it % 4 = 0 and it <= ip <= it + 3 and i = ip
  
   | After transformation:
   |
   | A[i,j] -> [it,j,ip] : it % 4 = 0 and it <= ip <= it + 3 and i = ip
   |
   | for (it = 0; it < 128; it+=4)
   |    for (j = 0; j < 128; j++)
   |      for (ip = max(0,it); ip < min(128, it + 3); ip++)
   |        A(ip,j);
  
   The goal of this transformation is to create a trivially vectorizable loop.
   This means a parallel loop at the innermost level that has a constant number
   of iterations corresponding to the target vector width.
  
   This transformation creates a loop at the innermost level. The loop has a
   constant number of iterations, if the number of loop iterations at
   DimToVectorize can be devided by VectorWidth. The default VectorWidth is
   currently constant and not yet target specific. This function does not reason
   about parallelism.

Referenced by getScheduleForBandList().

static isl_union_map* getScheduleForBand ( )

static

References DisableTiling, and getTileMap().

Referenced by getScheduleForBandList().

static isl_union_map* getScheduleForBandList ( )

static

getScheduleForBandList - Get the scheduling map for a list of bands.
    
   We walk recursively the forest of bands to combine the schedules of the
   individual bands to the overall schedule. In case tiling is requested,
   the individual bands are tiled.

References EnablePollyVector, getPrevectorMap(), and getScheduleForBand().

Referenced by getScheduleMap().

static isl_union_map* getScheduleMap ( )

static

References getScheduleForBandList().

Referenced by optimize_isl().

static int getSingleMap ( )

static

References map.

Referenced by apply_schedule_map_to_scop().

static isl_basic_map* getTileMap ( )

static

getTileMap - Create a map that describes a n-dimensonal tiling.
  
   getTileMap creates a map from a n-dimensional scattering space into an
   2*n-dimensional scattering space. The map describes a rectangular tiling.
  
   Example:
     scheduleDimensions = 2, parameterDimensions = 1, tileSize = 32
 
    tileMap := [p0] -> {[s0, s1] -> [t0, t1, s0, s1]:
                         t0 % 32 = 0 and t0 <= s0 < t0 + 32 and
                         t1 % 32 = 0 and t1 <= s1 < t1 + 32}
 
   Before tiling:
 
   for (i = 0; i < N; i++)
     for (j = 0; j < M; j++)
        S(i,j)
 
   After tiling:
 
   for (t_i = 0; t_i < N; i+=32)
     for (t_j = 0; t_j < M; j+=32)
        for (i = t_i; i < min(t_i + 32, N); i++)  | Unknown that N % 32 = 0
          for (j = t_j; j < t_j + 32; j++)        |   Known that M % 32 = 0
            S(i,j)

Referenced by getScheduleForBand().

bool optimize_isl ( )

References apply_schedule_map_to_scop(), CONSTANT_BOUND, scop::ctx, getScheduleMap(), scop_get_dependences(), and scop_get_domains().

Referenced by apply_poly_transforms().

static isl_union_map* scop_get_dependences ( )

static

References compute_deps(), scop::may_raw, scop::may_raw_no_source, scop::may_war, scop::may_war_no_source, scop::may_waw, scop::may_waw_no_source, scop::must_raw, scop::must_raw_no_source, scop::must_war, scop::must_war_no_source, scop::must_waw, and scop::must_waw_no_source.

Referenced by optimize_isl().

static isl_union_set* scop_get_domains ( )

static

@verbatim A scheduling optimizer for Graphite

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

References scop::bbs, scop::context, and poly_bb::domain.

Referenced by optimize_isl().

Variable Documentation

const int CONSTANT_BOUND = 20

static

Referenced by optimize_isl().

bool DisableTiling = false

static

getScheduleForBand - Get the schedule for this band.
  
   Polly applies transformations like tiling on top of the isl calculated value.
   This can influence the number of scheduling dimension. The number of
   schedule dimensions is returned in the parameter 'Dimension'.

Referenced by getScheduleForBand().

bool EnablePollyVector = false

static

Referenced by getScheduleForBandList().

Functions

Variables

Function Documentation

Variable Documentation