Refactor optimize isl
Refactor graphite-optimize-isl.c. Renamed function name, variable names etc.,
and indented the source according to gcc style guidelines. Modified comments
accordingly. No functional change intended.
Passes regtest and bootstap on x86_64.
gcc/ChangeLog:
2015-09-10 Aditya Kumar <aditya.k7@samsung.com>
* graphite-optimize-isl.c (get_tile_map): Refactor.
(get_schedule_for_band): Same.
(getScheduleForBand): Same.
(get_prevector_map): Same.
(get_schedule_for_band_list): Same.
(get_schedule_map): Same.
(get_single_map): Same.
(apply_schedule_map_to_scop): Same.
(optimize_isl): Same.
From-SVN: r227695
This commit is contained in:
Aditya Kumar
Sebastian Pop
parent
fc00244420
commit
ec62c3731d
2 changed files with 221 additions and 205 deletions
|
|
@ -1,3 +1,15 @@
|
|||
2015-09-11 Aditya Kumar <aditya.k7@samsung.com>
|
||||
|
||||
* graphite-optimize-isl.c (get_tile_map): Refactor.
|
||||
(get_schedule_for_band): Same.
|
||||
(getScheduleForBand): Same.
|
||||
(get_prevector_map): Same.
|
||||
(get_schedule_for_band_list): Same.
|
||||
(get_schedule_map): Same.
|
||||
(get_single_map): Same.
|
||||
(apply_schedule_map_to_scop): Same.
|
||||
(optimize_isl): Same.
|
||||
|
||||
2015-09-10 Ramana Radhakrishnan <ramana.radhakrishnan@arm.com>
|
||||
|
||||
PR target/63304
|
||||
|
|
|
|||
|
|
@ -50,6 +50,9 @@ along with GCC; see the file COPYING3. If not see
|
|||
#include "params.h"
|
||||
#include "dumpfile.h"
|
||||
|
||||
/* Set this to true to disable tiling of nested loops. */
|
||||
static bool disable_tiling = false;
|
||||
|
||||
static isl_union_set *
|
||||
scop_get_domains (scop_p scop ATTRIBUTE_UNUSED)
|
||||
{
|
||||
|
|
@ -64,152 +67,153 @@ scop_get_domains (scop_p scop ATTRIBUTE_UNUSED)
|
|||
return res;
|
||||
}
|
||||
|
||||
/* getTileMap - Create a map that describes a n-dimensonal tiling.
|
||||
|
||||
getTileMap creates a map from a n-dimensional scattering space into an
|
||||
/* get_tile_map - Create a map that describes a n-dimensonal tiling.
|
||||
|
||||
get_tile_map 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}
|
||||
|
||||
SCHEDULE_DIMENSIONS = 2, PARAMETER_DIMENSIONS = 1, TILE_SIZE = 32
|
||||
|
||||
tile_map := [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)
|
||||
|
||||
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)
|
||||
*/
|
||||
|
||||
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)
|
||||
*/
|
||||
|
||||
static isl_basic_map *
|
||||
getTileMap (isl_ctx *ctx, int scheduleDimensions, int tileSize)
|
||||
get_tile_map (isl_ctx *ctx, int schedule_dimensions, int tile_size)
|
||||
{
|
||||
int x;
|
||||
/* We construct
|
||||
|
||||
tileMap := [p0] -> {[s0, s1] -> [t0, t1, p0, p1, a0, a1]:
|
||||
s0 = a0 * 32 and s0 = p0 and t0 <= p0 < t0 + 32 and
|
||||
s1 = a1 * 32 and s1 = p1 and t1 <= p1 < t1 + 32}
|
||||
tile_map := [p0] -> {[s0, s1] -> [t0, t1, p0, p1, a0, a1]:
|
||||
s0 = a0 * 32 and s0 = p0 and t0 <= p0 < t0 + 32 and
|
||||
s1 = a1 * 32 and s1 = p1 and t1 <= p1 < t1 + 32}
|
||||
|
||||
and project out the auxilary dimensions a0 and a1. */
|
||||
isl_space *Space = isl_space_alloc (ctx, 0, scheduleDimensions,
|
||||
scheduleDimensions * 3);
|
||||
isl_basic_map *tileMap = isl_basic_map_universe (isl_space_copy (Space));
|
||||
isl_space *space
|
||||
= isl_space_alloc (ctx, 0, schedule_dimensions, schedule_dimensions * 3);
|
||||
isl_basic_map *tile_map = isl_basic_map_universe (isl_space_copy (space));
|
||||
|
||||
isl_local_space *LocalSpace = isl_local_space_from_space (Space);
|
||||
isl_local_space *local_space = isl_local_space_from_space (space);
|
||||
|
||||
for (x = 0; x < scheduleDimensions; x++)
|
||||
for (int x = 0; x < schedule_dimensions; x++)
|
||||
{
|
||||
int sX = x;
|
||||
int tX = x;
|
||||
int pX = scheduleDimensions + x;
|
||||
int aX = 2 * scheduleDimensions + x;
|
||||
int pX = schedule_dimensions + x;
|
||||
int aX = 2 * schedule_dimensions + x;
|
||||
|
||||
isl_constraint *c;
|
||||
|
||||
/* sX = aX * tileSize; */
|
||||
c = isl_equality_alloc (isl_local_space_copy (LocalSpace));
|
||||
/* sX = aX * tile_size; */
|
||||
c = isl_equality_alloc (isl_local_space_copy (local_space));
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, sX, 1);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, aX, -tileSize);
|
||||
tileMap = isl_basic_map_add_constraint (tileMap, c);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, aX, -tile_size);
|
||||
tile_map = isl_basic_map_add_constraint (tile_map, c);
|
||||
|
||||
/* pX = sX; */
|
||||
c = isl_equality_alloc (isl_local_space_copy (LocalSpace));
|
||||
c = isl_equality_alloc (isl_local_space_copy (local_space));
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, pX, 1);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_in, sX, -1);
|
||||
tileMap = isl_basic_map_add_constraint (tileMap, c);
|
||||
tile_map = isl_basic_map_add_constraint (tile_map, c);
|
||||
|
||||
/* tX <= pX */
|
||||
c = isl_inequality_alloc (isl_local_space_copy (LocalSpace));
|
||||
c = isl_inequality_alloc (isl_local_space_copy (local_space));
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, pX, 1);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, tX, -1);
|
||||
tileMap = isl_basic_map_add_constraint (tileMap, c);
|
||||
tile_map = isl_basic_map_add_constraint (tile_map, c);
|
||||
|
||||
/* pX <= tX + (tileSize - 1) */
|
||||
c = isl_inequality_alloc (isl_local_space_copy (LocalSpace));
|
||||
/* pX <= tX + (tile_size - 1) */
|
||||
c = isl_inequality_alloc (isl_local_space_copy (local_space));
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, tX, 1);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, pX, -1);
|
||||
isl_constraint_set_constant_si (c, tileSize - 1);
|
||||
tileMap = isl_basic_map_add_constraint (tileMap, c);
|
||||
isl_constraint_set_constant_si (c, tile_size - 1);
|
||||
tile_map = isl_basic_map_add_constraint (tile_map, c);
|
||||
}
|
||||
|
||||
/* Project out auxiliary dimensions.
|
||||
|
||||
The auxiliary dimensions are transformed into existentially quantified ones.
|
||||
This reduces the number of visible scattering dimensions and allows Cloog
|
||||
The auxiliary dimensions are transformed into existentially quantified
|
||||
ones.
|
||||
This reduces the number of visible scattering dimensions and allows isl
|
||||
to produces better code. */
|
||||
tileMap = isl_basic_map_project_out (tileMap, isl_dim_out,
|
||||
2 * scheduleDimensions,
|
||||
scheduleDimensions);
|
||||
isl_local_space_free (LocalSpace);
|
||||
return tileMap;
|
||||
tile_map =
|
||||
isl_basic_map_project_out (tile_map, isl_dim_out,
|
||||
2 * schedule_dimensions, schedule_dimensions);
|
||||
isl_local_space_free (local_space);
|
||||
return tile_map;
|
||||
}
|
||||
|
||||
/* getScheduleForBand - Get the schedule for this band.
|
||||
|
||||
Polly applies transformations like tiling on top of the isl calculated value.
|
||||
/* get_schedule_for_band - 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'. */
|
||||
static bool DisableTiling = false;
|
||||
schedule dimensions is returned in DIMENSIONS. */
|
||||
|
||||
static isl_union_map *
|
||||
getScheduleForBand (isl_band *Band, int *Dimensions)
|
||||
get_schedule_for_band (isl_band *band, int *dimensions)
|
||||
{
|
||||
isl_union_map *PartialSchedule;
|
||||
isl_union_map *partial_schedule;
|
||||
isl_ctx *ctx;
|
||||
isl_space *Space;
|
||||
isl_basic_map *TileMap;
|
||||
isl_union_map *TileUMap;
|
||||
isl_space *space;
|
||||
isl_basic_map *tile_map;
|
||||
isl_union_map *tile_umap;
|
||||
|
||||
PartialSchedule = isl_band_get_partial_schedule (Band);
|
||||
*Dimensions = isl_band_n_member (Band);
|
||||
partial_schedule = isl_band_get_partial_schedule (band);
|
||||
*dimensions = isl_band_n_member (band);
|
||||
|
||||
if (DisableTiling)
|
||||
return PartialSchedule;
|
||||
if (disable_tiling)
|
||||
return partial_schedule;
|
||||
|
||||
/* It does not make any sense to tile a band with just one dimension. */
|
||||
if (*Dimensions == 1)
|
||||
if (*dimensions == 1)
|
||||
{
|
||||
if (dump_file && dump_flags)
|
||||
fprintf (dump_file, "not tiled\n");
|
||||
return PartialSchedule;
|
||||
return partial_schedule;
|
||||
}
|
||||
|
||||
if (dump_file && dump_flags)
|
||||
fprintf (dump_file, "tiled by %d\n",
|
||||
PARAM_VALUE (PARAM_LOOP_BLOCK_TILE_SIZE));
|
||||
|
||||
ctx = isl_union_map_get_ctx (PartialSchedule);
|
||||
Space = isl_union_map_get_space (PartialSchedule);
|
||||
ctx = isl_union_map_get_ctx (partial_schedule);
|
||||
space = isl_union_map_get_space (partial_schedule);
|
||||
|
||||
TileMap = getTileMap (ctx, *Dimensions,
|
||||
PARAM_VALUE (PARAM_LOOP_BLOCK_TILE_SIZE));
|
||||
TileUMap = isl_union_map_from_map (isl_map_from_basic_map (TileMap));
|
||||
TileUMap = isl_union_map_align_params (TileUMap, Space);
|
||||
*Dimensions = 2 * *Dimensions;
|
||||
tile_map = get_tile_map (ctx, *dimensions,
|
||||
PARAM_VALUE (PARAM_LOOP_BLOCK_TILE_SIZE));
|
||||
tile_umap = isl_union_map_from_map (isl_map_from_basic_map (tile_map));
|
||||
tile_umap = isl_union_map_align_params (tile_umap, space);
|
||||
*dimensions = 2 * *dimensions;
|
||||
|
||||
return isl_union_map_apply_range (PartialSchedule, TileUMap);
|
||||
return isl_union_map_apply_range (partial_schedule, tile_umap);
|
||||
}
|
||||
|
||||
/* 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):
|
||||
|
||||
|
||||
get_prevector_map creates a map that maps each input dimension to the same
|
||||
output dimension, except for the dimension DIM_TO_VECTORIZE.
|
||||
DIM_TO_VECTORIZE is
|
||||
strip mined by 'VECTOR_WIDTH' and the newly created point loop of
|
||||
DIM_TO_VECTORIZE is moved to the innermost level.
|
||||
|
||||
Example (DIM_TO_VECTORIZE=0, SCHEDULE_DIMENSIONS=2,VECTOR_WIDTH=4):
|
||||
|
||||
| Before transformation
|
||||
|
|
||||
| A[i,j] -> [i,j]
|
||||
|
|
@ -217,10 +221,10 @@ getScheduleForBand (isl_band *Band, int *Dimensions)
|
|||
| 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
|
||||
|
|
@ -229,170 +233,171 @@ getScheduleForBand (isl_band *Band, int *Dimensions)
|
|||
| 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. */
|
||||
DIM_TO_VECTORIZE can be devided by VECTOR_WIDTH. The default VECTOR_WIDTH is
|
||||
currently constant and not yet target specific. This function does not
|
||||
reason about parallelism. */
|
||||
static isl_map *
|
||||
getPrevectorMap (isl_ctx *ctx, int DimToVectorize,
|
||||
int ScheduleDimensions,
|
||||
int VectorWidth)
|
||||
get_prevector_map (isl_ctx *ctx, int dim_to_vectorize, int schedule_dimensions,
|
||||
int vector_width)
|
||||
{
|
||||
isl_space *Space;
|
||||
isl_local_space *LocalSpace, *LocalSpaceRange;
|
||||
isl_set *Modulo;
|
||||
isl_map *TilingMap;
|
||||
isl_space *space;
|
||||
isl_local_space *local_space, *local_space_range;
|
||||
isl_set *modulo;
|
||||
isl_map *tiling_map;
|
||||
isl_constraint *c;
|
||||
isl_aff *Aff;
|
||||
int PointDimension; /* ip */
|
||||
int TileDimension; /* it */
|
||||
isl_val *VectorWidthMP;
|
||||
isl_aff *aff;
|
||||
int point_dimension; /* ip */
|
||||
int tile_dimension; /* it */
|
||||
isl_val *vector_widthMP;
|
||||
int i;
|
||||
|
||||
/* assert (0 <= DimToVectorize && DimToVectorize < ScheduleDimensions);*/
|
||||
|
||||
Space = isl_space_alloc (ctx, 0, ScheduleDimensions, ScheduleDimensions + 1);
|
||||
TilingMap = isl_map_universe (isl_space_copy (Space));
|
||||
LocalSpace = isl_local_space_from_space (Space);
|
||||
PointDimension = ScheduleDimensions;
|
||||
TileDimension = DimToVectorize;
|
||||
space
|
||||
= isl_space_alloc (ctx, 0, schedule_dimensions, schedule_dimensions + 1);
|
||||
tiling_map = isl_map_universe (isl_space_copy (space));
|
||||
local_space = isl_local_space_from_space (space);
|
||||
point_dimension = schedule_dimensions;
|
||||
tile_dimension = dim_to_vectorize;
|
||||
|
||||
/* Create an identity map for everything except DimToVectorize and map
|
||||
DimToVectorize to the point loop at the innermost dimension. */
|
||||
for (i = 0; i < ScheduleDimensions; i++)
|
||||
for (i = 0; i < schedule_dimensions; i++)
|
||||
{
|
||||
c = isl_equality_alloc (isl_local_space_copy (LocalSpace));
|
||||
c = isl_equality_alloc (isl_local_space_copy (local_space));
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_in, i, -1);
|
||||
|
||||
if (i == DimToVectorize)
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, 1);
|
||||
if (i == dim_to_vectorize)
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, point_dimension, 1);
|
||||
else
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, i, 1);
|
||||
|
||||
TilingMap = isl_map_add_constraint (TilingMap, c);
|
||||
tiling_map = isl_map_add_constraint (tiling_map, c);
|
||||
}
|
||||
|
||||
/* it % 'VectorWidth' = 0 */
|
||||
LocalSpaceRange = isl_local_space_range (isl_local_space_copy (LocalSpace));
|
||||
Aff = isl_aff_zero_on_domain (LocalSpaceRange);
|
||||
Aff = isl_aff_set_constant_si (Aff, VectorWidth);
|
||||
Aff = isl_aff_set_coefficient_si (Aff, isl_dim_in, TileDimension, 1);
|
||||
local_space_range
|
||||
= isl_local_space_range (isl_local_space_copy (local_space));
|
||||
aff = isl_aff_zero_on_domain (local_space_range);
|
||||
aff = isl_aff_set_constant_si (aff, vector_width);
|
||||
aff = isl_aff_set_coefficient_si (aff, isl_dim_in, tile_dimension, 1);
|
||||
|
||||
VectorWidthMP = isl_val_int_from_si (ctx, VectorWidth);
|
||||
Aff = isl_aff_mod_val (Aff, VectorWidthMP);
|
||||
Modulo = isl_pw_aff_zero_set (isl_pw_aff_from_aff (Aff));
|
||||
TilingMap = isl_map_intersect_range (TilingMap, Modulo);
|
||||
vector_widthMP = isl_val_int_from_si (ctx, vector_width);
|
||||
aff = isl_aff_mod_val (aff, vector_widthMP);
|
||||
modulo = isl_pw_aff_zero_set (isl_pw_aff_from_aff (aff));
|
||||
tiling_map = isl_map_intersect_range (tiling_map, modulo);
|
||||
|
||||
/* it <= ip */
|
||||
c = isl_inequality_alloc (isl_local_space_copy (LocalSpace));
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, TileDimension, -1);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, 1);
|
||||
TilingMap = isl_map_add_constraint (TilingMap, c);
|
||||
c = isl_inequality_alloc (isl_local_space_copy (local_space));
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, tile_dimension, -1);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, point_dimension, 1);
|
||||
tiling_map = isl_map_add_constraint (tiling_map, c);
|
||||
|
||||
/* ip <= it + ('VectorWidth' - 1) */
|
||||
c = isl_inequality_alloc (LocalSpace);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, TileDimension, 1);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, -1);
|
||||
isl_constraint_set_constant_si (c, VectorWidth - 1);
|
||||
TilingMap = isl_map_add_constraint (TilingMap, c);
|
||||
c = isl_inequality_alloc (local_space);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, tile_dimension, 1);
|
||||
isl_constraint_set_coefficient_si (c, isl_dim_out, point_dimension, -1);
|
||||
isl_constraint_set_constant_si (c, vector_width - 1);
|
||||
tiling_map = isl_map_add_constraint (tiling_map, c);
|
||||
|
||||
return TilingMap;
|
||||
return tiling_map;
|
||||
}
|
||||
|
||||
static bool EnablePollyVector = false;
|
||||
static bool enable_polly_vector = false;
|
||||
|
||||
/* getScheduleForBandList - Get the scheduling map for a list of bands.
|
||||
/* get_schedule_for_band_list - 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,
|
||||
individual bands to the overall schedule. In case tiling is requested,
|
||||
the individual bands are tiled. */
|
||||
static isl_union_map *
|
||||
getScheduleForBandList (isl_band_list *BandList)
|
||||
get_schedule_for_band_list (isl_band_list *band_list)
|
||||
{
|
||||
int NumBands, i;
|
||||
isl_union_map *Schedule;
|
||||
int num_bands, i;
|
||||
isl_union_map *schedule;
|
||||
isl_ctx *ctx;
|
||||
|
||||
ctx = isl_band_list_get_ctx (BandList);
|
||||
NumBands = isl_band_list_n_band (BandList);
|
||||
Schedule = isl_union_map_empty (isl_space_params_alloc (ctx, 0));
|
||||
ctx = isl_band_list_get_ctx (band_list);
|
||||
num_bands = isl_band_list_n_band (band_list);
|
||||
schedule = isl_union_map_empty (isl_space_params_alloc (ctx, 0));
|
||||
|
||||
for (i = 0; i < NumBands; i++)
|
||||
for (i = 0; i < num_bands; i++)
|
||||
{
|
||||
isl_band *Band;
|
||||
isl_union_map *PartialSchedule;
|
||||
int ScheduleDimensions;
|
||||
isl_space *Space;
|
||||
isl_band *band;
|
||||
isl_union_map *partial_schedule;
|
||||
int schedule_dimensions;
|
||||
isl_space *space;
|
||||
|
||||
Band = isl_band_list_get_band (BandList, i);
|
||||
PartialSchedule = getScheduleForBand (Band, &ScheduleDimensions);
|
||||
Space = isl_union_map_get_space (PartialSchedule);
|
||||
band = isl_band_list_get_band (band_list, i);
|
||||
partial_schedule = get_schedule_for_band (band, &schedule_dimensions);
|
||||
space = isl_union_map_get_space (partial_schedule);
|
||||
|
||||
if (isl_band_has_children (Band))
|
||||
if (isl_band_has_children (band))
|
||||
{
|
||||
isl_band_list *Children;
|
||||
isl_union_map *SuffixSchedule;
|
||||
|
||||
Children = isl_band_get_children (Band);
|
||||
SuffixSchedule = getScheduleForBandList (Children);
|
||||
PartialSchedule = isl_union_map_flat_range_product (PartialSchedule,
|
||||
SuffixSchedule);
|
||||
isl_band_list_free (Children);
|
||||
isl_band_list *children = isl_band_get_children (band);
|
||||
isl_union_map *suffixSchedule
|
||||
= get_schedule_for_band_list (children);
|
||||
partial_schedule
|
||||
= isl_union_map_flat_range_product (partial_schedule,
|
||||
suffixSchedule);
|
||||
isl_band_list_free (children);
|
||||
}
|
||||
else if (EnablePollyVector)
|
||||
else if (enable_polly_vector)
|
||||
{
|
||||
for (i = ScheduleDimensions - 1 ; i >= 0 ; i--)
|
||||
for (i = schedule_dimensions - 1; i >= 0; i--)
|
||||
{
|
||||
#ifdef HAVE_ISL_SCHED_CONSTRAINTS_COMPUTE_SCHEDULE
|
||||
if (isl_band_member_is_coincident (Band, i))
|
||||
if (isl_band_member_is_coincident (band, i))
|
||||
#else
|
||||
if (isl_band_member_is_zero_distance (Band, i))
|
||||
if (isl_band_member_is_zero_distance (band, i))
|
||||
#endif
|
||||
{
|
||||
isl_map *TileMap;
|
||||
isl_union_map *TileUMap;
|
||||
|
||||
TileMap = getPrevectorMap (ctx, i, ScheduleDimensions, 4);
|
||||
TileUMap = isl_union_map_from_map (TileMap);
|
||||
TileUMap = isl_union_map_align_params
|
||||
(TileUMap, isl_space_copy (Space));
|
||||
PartialSchedule = isl_union_map_apply_range
|
||||
(PartialSchedule, TileUMap);
|
||||
/* FIXME: The default VECTOR_WIDTH is currently constant and
|
||||
* not yet target specific. */
|
||||
isl_map *tile_map
|
||||
= get_prevector_map (ctx, i, schedule_dimensions, 4);
|
||||
isl_union_map *tile_umap = isl_union_map_from_map (tile_map);
|
||||
tile_umap
|
||||
= isl_union_map_align_params (tile_umap,
|
||||
isl_space_copy (space));
|
||||
partial_schedule
|
||||
= isl_union_map_apply_range (partial_schedule,
|
||||
tile_umap);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Schedule = isl_union_map_union (Schedule, PartialSchedule);
|
||||
schedule = isl_union_map_union (schedule, partial_schedule);
|
||||
|
||||
isl_band_free (Band);
|
||||
isl_space_free (Space);
|
||||
isl_band_free (band);
|
||||
isl_space_free (space);
|
||||
}
|
||||
|
||||
return Schedule;
|
||||
return schedule;
|
||||
}
|
||||
|
||||
static isl_union_map *
|
||||
getScheduleMap (isl_schedule *Schedule)
|
||||
get_schedule_map (isl_schedule *schedule)
|
||||
{
|
||||
isl_band_list *BandList = isl_schedule_get_band_forest (Schedule);
|
||||
isl_union_map *ScheduleMap = getScheduleForBandList (BandList);
|
||||
isl_band_list_free (BandList);
|
||||
return ScheduleMap;
|
||||
isl_band_list *bandList = isl_schedule_get_band_forest (schedule);
|
||||
isl_union_map *schedule_map = get_schedule_for_band_list (bandList);
|
||||
isl_band_list_free (bandList);
|
||||
return schedule_map;
|
||||
}
|
||||
|
||||
static isl_stat
|
||||
getSingleMap (__isl_take isl_map *map, void *user)
|
||||
get_single_map (__isl_take isl_map *map, void *user)
|
||||
{
|
||||
isl_map **singleMap = (isl_map **) user;
|
||||
*singleMap = map;
|
||||
|
||||
isl_map **single_map = (isl_map **)user;
|
||||
*single_map = map;
|
||||
return isl_stat_ok;
|
||||
}
|
||||
|
||||
|
|
@ -405,16 +410,15 @@ apply_schedule_map_to_scop (scop_p scop, isl_union_map *schedule_map)
|
|||
FOR_EACH_VEC_ELT (scop->bbs, i, pbb)
|
||||
{
|
||||
isl_set *domain = isl_set_copy (pbb->domain);
|
||||
isl_union_map *stmtBand;
|
||||
isl_map *stmtSchedule;
|
||||
isl_map *stmt_schedule;
|
||||
|
||||
stmtBand = isl_union_map_intersect_domain
|
||||
(isl_union_map_copy (schedule_map),
|
||||
isl_union_set_from_set (domain));
|
||||
isl_union_map_foreach_map (stmtBand, getSingleMap, &stmtSchedule);
|
||||
isl_union_map *stmt_band
|
||||
= isl_union_map_intersect_domain (isl_union_map_copy (schedule_map),
|
||||
isl_union_set_from_set (domain));
|
||||
isl_union_map_foreach_map (stmt_band, get_single_map, &stmt_schedule);
|
||||
isl_map_free (pbb->transformed);
|
||||
pbb->transformed = stmtSchedule;
|
||||
isl_union_map_free (stmtBand);
|
||||
pbb->transformed = stmt_schedule;
|
||||
isl_union_map_free (stmt_band);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -424,19 +428,19 @@ bool
|
|||
optimize_isl (scop_p scop)
|
||||
{
|
||||
#ifdef HAVE_ISL_CTX_MAX_OPERATIONS
|
||||
int old_max_operations = isl_ctx_get_max_operations(scop->ctx);
|
||||
int old_max_operations = isl_ctx_get_max_operations (scop->ctx);
|
||||
int max_operations = PARAM_VALUE (PARAM_MAX_ISL_OPERATIONS);
|
||||
if (max_operations)
|
||||
isl_ctx_set_max_operations(scop->ctx, max_operations);
|
||||
isl_ctx_set_max_operations (scop->ctx, max_operations);
|
||||
#endif
|
||||
isl_options_set_on_error (scop->ctx, ISL_ON_ERROR_CONTINUE);
|
||||
|
||||
isl_union_set *domain = scop_get_domains (scop);
|
||||
isl_union_map *dependences = scop_get_dependences (scop);
|
||||
dependences = isl_union_map_gist_domain (dependences,
|
||||
isl_union_set_copy (domain));
|
||||
dependences = isl_union_map_gist_range (dependences,
|
||||
isl_union_set_copy (domain));
|
||||
dependences
|
||||
= isl_union_map_gist_domain (dependences, isl_union_set_copy (domain));
|
||||
dependences
|
||||
= isl_union_map_gist_range (dependences, isl_union_set_copy (domain));
|
||||
isl_union_map *validity = dependences;
|
||||
isl_union_map *proximity = isl_union_map_copy (validity);
|
||||
|
||||
|
|
@ -444,14 +448,14 @@ optimize_isl (scop_p scop)
|
|||
isl_schedule_constraints *schedule_constraints;
|
||||
schedule_constraints = isl_schedule_constraints_on_domain (domain);
|
||||
schedule_constraints
|
||||
= isl_schedule_constraints_set_proximity (schedule_constraints,
|
||||
proximity);
|
||||
= isl_schedule_constraints_set_proximity (schedule_constraints,
|
||||
proximity);
|
||||
schedule_constraints
|
||||
= isl_schedule_constraints_set_validity (schedule_constraints,
|
||||
isl_union_map_copy (validity));
|
||||
= isl_schedule_constraints_set_validity (schedule_constraints,
|
||||
isl_union_map_copy (validity));
|
||||
schedule_constraints
|
||||
= isl_schedule_constraints_set_coincidence (schedule_constraints,
|
||||
validity);
|
||||
= isl_schedule_constraints_set_coincidence (schedule_constraints,
|
||||
validity);
|
||||
#endif
|
||||
|
||||
isl_options_set_schedule_max_constant_term (scop->ctx, CONSTANT_BOUND);
|
||||
|
|
@ -473,8 +477,8 @@ optimize_isl (scop_p scop)
|
|||
isl_options_set_on_error (scop->ctx, ISL_ON_ERROR_ABORT);
|
||||
|
||||
#ifdef HAVE_ISL_CTX_MAX_OPERATIONS
|
||||
isl_ctx_reset_operations(scop->ctx);
|
||||
isl_ctx_set_max_operations(scop->ctx, old_max_operations);
|
||||
isl_ctx_reset_operations (scop->ctx);
|
||||
isl_ctx_set_max_operations (scop->ctx, old_max_operations);
|
||||
if (!schedule || isl_ctx_last_error (scop->ctx) == isl_error_quota)
|
||||
{
|
||||
if (dump_file && dump_flags)
|
||||
|
|
@ -489,7 +493,7 @@ optimize_isl (scop_p scop)
|
|||
return false;
|
||||
#endif
|
||||
|
||||
isl_union_map *schedule_map = getScheduleMap (schedule);
|
||||
isl_union_map *schedule_map = get_schedule_map (schedule);
|
||||
apply_schedule_map_to_scop (scop, schedule_map);
|
||||
|
||||
isl_schedule_free (schedule);
|
||||
|
|
@ -497,4 +501,4 @@ optimize_isl (scop_p scop)
|
|||
return true;
|
||||
}
|
||||
|
||||
#endif /* HAVE_isl */
|
||||
#endif /* HAVE_isl */
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue