From 8810e53d0fe3c804846cd38c16399562d4a77a0a Mon Sep 17 00:00:00 2001 From: spop Date: Fri, 11 Sep 2015 19:50:41 +0000 Subject: 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 * 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. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@227695 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/graphite-optimize-isl.c | 414 ++++++++++++++++++++++---------------------- 1 file changed, 209 insertions(+), 205 deletions(-) (limited to 'gcc/graphite-optimize-isl.c') diff --git a/gcc/graphite-optimize-isl.c b/gcc/graphite-optimize-isl.c index 811a510ad21..ea77fc7a163 100644 --- a/gcc/graphite-optimize-isl.c +++ b/gcc/graphite-optimize-isl.c @@ -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 */ -- cgit v1.2.1