static void
lst_project_loop (lst_p outer, lst_p inner, mpz_t stride)
{
int i;
lst_p stmt;
mpz_t x;
ppl_Coefficient_t one;
int outer_depth = lst_depth (outer);
int inner_depth = lst_depth (inner);
mpz_init (x);
mpz_set_si (x, 1);
ppl_new_Coefficient (&one);
ppl_assign_Coefficient_from_mpz_t (one, x);
FOR_EACH_VEC_ELT (lst_p, LST_SEQ (inner), i, stmt)
{
poly_bb_p pbb = LST_PBB (stmt);
ppl_Polyhedron_t poly = PBB_TRANSFORMED_SCATTERING (pbb);
ppl_dimension_type outer_dim = psct_dynamic_dim (pbb, outer_depth);
ppl_dimension_type inner_dim = psct_dynamic_dim (pbb, inner_depth);
ppl_Linear_Expression_t expr;
ppl_dimension_type dim;
ppl_dimension_type *ds;
/* There should be no loops under INNER. */
gcc_assert (!LST_LOOP_P (stmt));
ppl_Polyhedron_space_dimension (poly, &dim);
ppl_new_Linear_Expression_with_dimension (&expr, dim);
/* outer_dim = outer_dim * stride + inner_dim. */
ppl_set_coef (expr, inner_dim, 1);
ppl_set_coef_gmp (expr, outer_dim, stride);
ppl_Polyhedron_affine_image (poly, outer_dim, expr, one);
ppl_delete_Linear_Expression (expr);
/* Project on inner_dim. */
ppl_new_Linear_Expression_with_dimension (&expr, dim - 1);
ppl_Polyhedron_affine_image (poly, inner_dim, expr, one);
ppl_delete_Linear_Expression (expr);
/* Remove inner loop and the static schedule of its body. */
ds = XNEWVEC (ppl_dimension_type, 2);
ds[0] = inner_dim;
ds[1] = inner_dim + 1;
ppl_Polyhedron_remove_space_dimensions (poly, ds, 2);
PBB_NB_SCATTERING_TRANSFORM (pbb) -= 2;
free (ds);
}
static ppl_Constraint_t
cloog_matrix_to_ppl_constraint (CloogMatrix *matrix, int row)
{
int j;
ppl_Constraint_t cstr;
ppl_Coefficient_t coef;
ppl_Linear_Expression_t expr;
ppl_dimension_type dim = matrix->NbColumns - 2;
ppl_new_Coefficient (&coef);
ppl_new_Linear_Expression_with_dimension (&expr, dim);
for (j = 1; j < matrix->NbColumns - 1; j++)
{
ppl_assign_Coefficient_from_mpz_t (coef, matrix->p[row][j]);
ppl_Linear_Expression_add_to_coefficient (expr, j - 1, coef);
}
ppl_assign_Coefficient_from_mpz_t (coef,
matrix->p[row][matrix->NbColumns - 1]);
ppl_Linear_Expression_add_to_inhomogeneous (expr, coef);
ppl_delete_Coefficient (coef);
if (value_zero_p (matrix->p[row][0]))
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_EQUAL);
else
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_delete_Linear_Expression (expr);
return cstr;
}
static void
lst_scale (lst_p lst, lst_p stmt, mpz_t factor)
{
mpz_t x;
ppl_Coefficient_t one;
int outer_depth = lst_depth (lst);
poly_bb_p pbb = LST_PBB (stmt);
ppl_Polyhedron_t poly = PBB_TRANSFORMED_SCATTERING (pbb);
ppl_dimension_type outer_dim = psct_dynamic_dim (pbb, outer_depth);
ppl_Linear_Expression_t expr;
ppl_dimension_type dim;
mpz_init (x);
mpz_set_si (x, 1);
ppl_new_Coefficient (&one);
ppl_assign_Coefficient_from_mpz_t (one, x);
ppl_Polyhedron_space_dimension (poly, &dim);
ppl_new_Linear_Expression_with_dimension (&expr, dim);
/* outer_dim = factor * outer_dim. */
ppl_set_coef_gmp (expr, outer_dim, factor);
ppl_Polyhedron_affine_image (poly, outer_dim, expr, one);
ppl_delete_Linear_Expression (expr);
mpz_clear (x);
ppl_delete_Coefficient (one);
}
static void
lst_offset (lst_p stmt, mpz_t offset)
{
lst_p inner = LST_LOOP_FATHER (stmt);
poly_bb_p pbb = LST_PBB (stmt);
ppl_Polyhedron_t poly = PBB_TRANSFORMED_SCATTERING (pbb);
int inner_depth = lst_depth (inner);
ppl_dimension_type inner_dim = psct_dynamic_dim (pbb, inner_depth);
ppl_Linear_Expression_t expr;
ppl_dimension_type dim;
ppl_Coefficient_t one;
mpz_t x;
mpz_init (x);
mpz_set_si (x, 1);
ppl_new_Coefficient (&one);
ppl_assign_Coefficient_from_mpz_t (one, x);
ppl_Polyhedron_space_dimension (poly, &dim);
ppl_new_Linear_Expression_with_dimension (&expr, dim);
ppl_set_coef (expr, inner_dim, 1);
ppl_set_inhomogeneous_gmp (expr, offset);
ppl_Polyhedron_affine_image (poly, inner_dim, expr, one);
ppl_delete_Linear_Expression (expr);
ppl_delete_Coefficient (one);
}
static ppl_Pointset_Powerset_C_Polyhedron_t
dr_equality_constraints (graphite_dim_t dim,
graphite_dim_t pos, graphite_dim_t nb_subscripts)
{
ppl_Polyhedron_t subscript_equalities;
ppl_Pointset_Powerset_C_Polyhedron_t res;
Value v, v_op;
graphite_dim_t i;
value_init (v);
value_init (v_op);
value_set_si (v, 1);
value_set_si (v_op, -1);
ppl_new_C_Polyhedron_from_space_dimension (&subscript_equalities, dim, 0);
for (i = 0; i < nb_subscripts; i++)
{
ppl_Linear_Expression_t expr;
ppl_Constraint_t cstr;
ppl_Coefficient_t coef;
ppl_new_Coefficient (&coef);
ppl_new_Linear_Expression_with_dimension (&expr, dim);
ppl_assign_Coefficient_from_mpz_t (coef, v);
ppl_Linear_Expression_add_to_coefficient (expr, pos + i, coef);
ppl_assign_Coefficient_from_mpz_t (coef, v_op);
ppl_Linear_Expression_add_to_coefficient (expr, pos + i + nb_subscripts,
coef);
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_Polyhedron_add_constraint (subscript_equalities, cstr);
ppl_delete_Linear_Expression (expr);
ppl_delete_Constraint (cstr);
ppl_delete_Coefficient (coef);
}
ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron
(&res, subscript_equalities);
value_clear (v);
value_clear (v_op);
ppl_delete_Polyhedron (subscript_equalities);
return res;
}
void
open_hypercube(int dimension, ppl_Polyhedron_t ph) {
int i;
mpz_t z_one;
mpz_t z_minus_one;
ppl_Coefficient_t coeff_one;
ppl_Coefficient_t coeff_minus_one;
ppl_Linear_Expression_t le;
ppl_Constraint_t c;
ppl_Constraint_System_t cs;
mpz_init_set_si(z_one, 1);
mpz_init_set_si(z_minus_one, -1);
ppl_new_Coefficient(&coeff_one);
ppl_assign_Coefficient_from_mpz_t(coeff_one, z_one);
ppl_new_Coefficient(&coeff_minus_one);
ppl_assign_Coefficient_from_mpz_t(coeff_minus_one, z_minus_one);
ppl_new_Linear_Expression_with_dimension(&le, dimension);
ppl_new_Constraint_System(&cs);
for (i = 0; i < dimension; ++i) {
ppl_Linear_Expression_add_to_coefficient(le, i, coeff_one);
/* Variable(i) > 0 */
ppl_new_Constraint(&c, le, PPL_CONSTRAINT_TYPE_GREATER_THAN);
ppl_Constraint_System_insert_Constraint(cs, c);
ppl_delete_Constraint(c);
/* Variable(i) < 1 */
ppl_Linear_Expression_add_to_inhomogeneous(le, coeff_minus_one);
ppl_new_Constraint(&c, le, PPL_CONSTRAINT_TYPE_LESS_THAN);
ppl_Constraint_System_insert_Constraint(cs, c);
ppl_delete_Constraint(c);
/* Zero `le' */
ppl_Linear_Expression_add_to_coefficient(le, i, coeff_minus_one);
ppl_Linear_Expression_add_to_inhomogeneous(le, coeff_one);
}
ppl_Polyhedron_add_constraints(ph, cs);
ppl_delete_Constraint_System(cs);
ppl_delete_Linear_Expression(le);
ppl_delete_Coefficient(coeff_minus_one);
ppl_delete_Coefficient(coeff_one);
mpz_clear(z_minus_one);
mpz_clear(z_one);
}
static void
extend_scattering (poly_bb_p pbb, int max_scattering)
{
ppl_dimension_type nb_old_dims, nb_new_dims;
int nb_added_dims, i;
ppl_Coefficient_t coef;
Value one;
nb_added_dims = max_scattering - pbb_nb_scattering_transform (pbb);
value_init (one);
value_set_si (one, 1);
ppl_new_Coefficient (&coef);
ppl_assign_Coefficient_from_mpz_t (coef, one);
gcc_assert (nb_added_dims >= 0);
nb_old_dims = pbb_nb_scattering_transform (pbb) + pbb_dim_iter_domain (pbb)
+ scop_nb_params (PBB_SCOP (pbb));
nb_new_dims = nb_old_dims + nb_added_dims;
ppl_insert_dimensions (PBB_TRANSFORMED_SCATTERING (pbb),
pbb_nb_scattering_transform (pbb), nb_added_dims);
PBB_NB_SCATTERING_TRANSFORM (pbb) += nb_added_dims;
/* Add identity matrix for the added dimensions. */
for (i = max_scattering - nb_added_dims; i < max_scattering; i++)
{
ppl_Constraint_t cstr;
ppl_Linear_Expression_t expr;
ppl_new_Linear_Expression_with_dimension (&expr, nb_new_dims);
ppl_Linear_Expression_add_to_coefficient (expr, i, coef);
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_Polyhedron_add_constraint (PBB_TRANSFORMED_SCATTERING (pbb), cstr);
ppl_delete_Constraint (cstr);
ppl_delete_Linear_Expression (expr);
}
ppl_delete_Coefficient (coef);
value_clear (one);
}
static ppl_Constraint_t
build_pairwise_constraint (graphite_dim_t dim,
graphite_dim_t pos1, graphite_dim_t pos2,
int c, enum ppl_enum_Constraint_Type cstr_type)
{
ppl_Linear_Expression_t expr;
ppl_Constraint_t cstr;
ppl_Coefficient_t coef;
Value v, v_op, v_c;
value_init (v);
value_init (v_op);
value_init (v_c);
value_set_si (v, 1);
value_set_si (v_op, -1);
value_set_si (v_c, c);
ppl_new_Coefficient (&coef);
ppl_new_Linear_Expression_with_dimension (&expr, dim);
ppl_assign_Coefficient_from_mpz_t (coef, v);
ppl_Linear_Expression_add_to_coefficient (expr, pos1, coef);
ppl_assign_Coefficient_from_mpz_t (coef, v_op);
ppl_Linear_Expression_add_to_coefficient (expr, pos2, coef);
ppl_assign_Coefficient_from_mpz_t (coef, v_c);
ppl_Linear_Expression_add_to_inhomogeneous (expr, coef);
ppl_new_Constraint (&cstr, expr, cstr_type);
ppl_delete_Linear_Expression (expr);
ppl_delete_Coefficient (coef);
value_clear (v);
value_clear (v_op);
value_clear (v_c);
return cstr;
}
ppl_Constraint_t
ppl_build_relation (int dim, int pos1, int pos2, int c,
enum ppl_enum_Constraint_Type cstr_type)
{
ppl_Linear_Expression_t expr;
ppl_Constraint_t cstr;
ppl_Coefficient_t coef;
mpz_t v, v_op, v_c;
mpz_init (v);
mpz_init (v_op);
mpz_init (v_c);
mpz_set_si (v, 1);
mpz_set_si (v_op, -1);
mpz_set_si (v_c, c);
ppl_new_Coefficient (&coef);
ppl_new_Linear_Expression_with_dimension (&expr, dim);
ppl_assign_Coefficient_from_mpz_t (coef, v);
ppl_Linear_Expression_add_to_coefficient (expr, pos1, coef);
ppl_assign_Coefficient_from_mpz_t (coef, v_op);
ppl_Linear_Expression_add_to_coefficient (expr, pos2, coef);
ppl_assign_Coefficient_from_mpz_t (coef, v_c);
ppl_Linear_Expression_add_to_inhomogeneous (expr, coef);
ppl_new_Constraint (&cstr, expr, cstr_type);
ppl_delete_Linear_Expression (expr);
ppl_delete_Coefficient (coef);
mpz_clear (v);
mpz_clear (v_op);
mpz_clear (v_c);
return cstr;
}
static void
solve(char* file_name) {
ppl_Constraint_System_t ppl_cs;
#ifndef NDEBUG
ppl_Constraint_System_t ppl_cs_copy;
#endif
ppl_Generator_t optimum_location;
ppl_Linear_Expression_t ppl_le;
int dimension, row, num_rows, column, nz, i, j, type;
int* coefficient_index;
double lb, ub;
double* coefficient_value;
mpq_t rational_lb, rational_ub;
mpq_t* rational_coefficient;
mpq_t* objective;
ppl_Linear_Expression_t ppl_objective_le;
ppl_Coefficient_t optimum_n;
ppl_Coefficient_t optimum_d;
mpq_t optimum;
mpz_t den_lcm;
int optimum_found;
glp_mpscp glpk_mpscp;
glpk_lp = glp_create_prob();
glp_init_mpscp(&glpk_mpscp);
if (verbosity == 0) {
/* FIXME: find a way to suppress output from glp_read_mps. */
}
#ifdef PPL_LPSOL_SUPPORTS_TIMINGS
if (print_timings)
start_clock();
#endif /* defined(PPL_LPSOL_SUPPORTS_TIMINGS) */
if (glp_read_mps(glpk_lp, GLP_MPS_FILE, &glpk_mpscp, file_name) != 0)
fatal("cannot read MPS file `%s'", file_name);
#ifdef PPL_LPSOL_SUPPORTS_TIMINGS
if (print_timings) {
fprintf(stderr, "Time to read the input file: ");
print_clock(stderr);
fprintf(stderr, " s\n");
start_clock();
}
#endif /* defined(PPL_LPSOL_SUPPORTS_TIMINGS) */
glpk_lp_num_int = glp_get_num_int(glpk_lp);
if (glpk_lp_num_int > 0 && !no_mip && !use_simplex)
fatal("the enumeration solving method can not handle MIP problems");
dimension = glp_get_num_cols(glpk_lp);
/* Read variables constrained to be integer. */
if (glpk_lp_num_int > 0 && !no_mip && use_simplex) {
if (verbosity >= 4)
fprintf(output_file, "Integer variables:\n");
integer_variables = (ppl_dimension_type*)
malloc((glpk_lp_num_int + 1)*sizeof(ppl_dimension_type));
for (i = 0, j = 0; i < dimension; ++i) {
int col_kind = glp_get_col_kind(glpk_lp, i+1);
if (col_kind == GLP_IV || col_kind == GLP_BV) {
integer_variables[j] = i;
if (verbosity >= 4) {
ppl_io_fprint_variable(output_file, i);
fprintf(output_file, " ");
}
++j;
}
}
}
coefficient_index = (int*) malloc((dimension+1)*sizeof(int));
coefficient_value = (double*) malloc((dimension+1)*sizeof(double));
rational_coefficient = (mpq_t*) malloc((dimension+1)*sizeof(mpq_t));
ppl_new_Constraint_System(&ppl_cs);
mpq_init(rational_lb);
mpq_init(rational_ub);
for (i = 1; i <= dimension; ++i)
mpq_init(rational_coefficient[i]);
mpz_init(den_lcm);
if (verbosity >= 4)
fprintf(output_file, "\nConstraints:\n");
/* Set up the row (ordinary) constraints. */
num_rows = glp_get_num_rows(glpk_lp);
for (row = 1; row <= num_rows; ++row) {
/* Initialize the least common multiple computation. */
mpz_set_si(den_lcm, 1);
/* Set `nz' to the number of non-zero coefficients. */
nz = glp_get_mat_row(glpk_lp, row, coefficient_index, coefficient_value);
for (i = 1; i <= nz; ++i) {
set_mpq_t_from_double(rational_coefficient[i], coefficient_value[i]);
/* Update den_lcm. */
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_coefficient[i]));
}
lb = glp_get_row_lb(glpk_lp, row);
ub = glp_get_row_ub(glpk_lp, row);
set_mpq_t_from_double(rational_lb, lb);
set_mpq_t_from_double(rational_ub, ub);
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_lb));
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_ub));
ppl_new_Linear_Expression_with_dimension(&ppl_le, dimension);
for (i = 1; i <= nz; ++i) {
mpz_mul(tmp_z, den_lcm, mpq_numref(rational_coefficient[i]));
mpz_divexact(tmp_z, tmp_z, mpq_denref(rational_coefficient[i]));
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, tmp_z);
ppl_Linear_Expression_add_to_coefficient(ppl_le, coefficient_index[i]-1,
ppl_coeff);
}
type = glp_get_row_type(glpk_lp, row);
add_constraints(ppl_le, type, rational_lb, rational_ub, den_lcm, ppl_cs);
ppl_delete_Linear_Expression(ppl_le);
}
free(coefficient_value);
for (i = 1; i <= dimension; ++i)
mpq_clear(rational_coefficient[i]);
free(rational_coefficient);
free(coefficient_index);
#ifndef NDEBUG
ppl_new_Constraint_System_from_Constraint_System(&ppl_cs_copy, ppl_cs);
#endif
/*
FIXME: here we could build the polyhedron and minimize it before
adding the variable bounds.
*/
/* Set up the columns constraints, i.e., variable bounds. */
for (column = 1; column <= dimension; ++column) {
lb = glp_get_col_lb(glpk_lp, column);
ub = glp_get_col_ub(glpk_lp, column);
set_mpq_t_from_double(rational_lb, lb);
set_mpq_t_from_double(rational_ub, ub);
/* Initialize the least common multiple computation. */
mpz_set_si(den_lcm, 1);
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_lb));
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_ub));
ppl_new_Linear_Expression_with_dimension(&ppl_le, dimension);
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, den_lcm);
ppl_Linear_Expression_add_to_coefficient(ppl_le, column-1, ppl_coeff);
type = glp_get_col_type(glpk_lp, column);
add_constraints(ppl_le, type, rational_lb, rational_ub, den_lcm, ppl_cs);
ppl_delete_Linear_Expression(ppl_le);
}
mpq_clear(rational_ub);
mpq_clear(rational_lb);
/* Deal with the objective function. */
objective = (mpq_t*) malloc((dimension+1)*sizeof(mpq_t));
/* Initialize the least common multiple computation. */
mpz_set_si(den_lcm, 1);
mpq_init(objective[0]);
set_mpq_t_from_double(objective[0], glp_get_obj_coef(glpk_lp, 0));
for (i = 1; i <= dimension; ++i) {
mpq_init(objective[i]);
set_mpq_t_from_double(objective[i], glp_get_obj_coef(glpk_lp, i));
/* Update den_lcm. */
mpz_lcm(den_lcm, den_lcm, mpq_denref(objective[i]));
}
/* Set the ppl_objective_le to be the objective function. */
ppl_new_Linear_Expression_with_dimension(&ppl_objective_le, dimension);
/* Set value for objective function's inhomogeneous term. */
mpz_mul(tmp_z, den_lcm, mpq_numref(objective[0]));
mpz_divexact(tmp_z, tmp_z, mpq_denref(objective[0]));
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, tmp_z);
ppl_Linear_Expression_add_to_inhomogeneous(ppl_objective_le, ppl_coeff);
/* Set values for objective function's variable coefficients. */
for (i = 1; i <= dimension; ++i) {
mpz_mul(tmp_z, den_lcm, mpq_numref(objective[i]));
mpz_divexact(tmp_z, tmp_z, mpq_denref(objective[i]));
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, tmp_z);
ppl_Linear_Expression_add_to_coefficient(ppl_objective_le, i-1, ppl_coeff);
}
if (verbosity >= 4) {
fprintf(output_file, "Objective function:\n");
if (mpz_cmp_si(den_lcm, 1) != 0)
fprintf(output_file, "(");
ppl_io_fprint_Linear_Expression(output_file, ppl_objective_le);
}
for (i = 0; i <= dimension; ++i)
mpq_clear(objective[i]);
free(objective);
if (verbosity >= 4) {
if (mpz_cmp_si(den_lcm, 1) != 0) {
fprintf(output_file, ")/");
mpz_out_str(output_file, 10, den_lcm);
}
fprintf(output_file, "\n%s\n",
(maximize ? "Maximizing." : "Minimizing."));
}
ppl_new_Coefficient(&optimum_n);
ppl_new_Coefficient(&optimum_d);
ppl_new_Generator_zero_dim_point(&optimum_location);
optimum_found = use_simplex
? solve_with_simplex(ppl_cs,
ppl_objective_le,
optimum_n,
optimum_d,
optimum_location)
: solve_with_generators(ppl_cs,
ppl_objective_le,
optimum_n,
optimum_d,
optimum_location);
ppl_delete_Linear_Expression(ppl_objective_le);
if (glpk_lp_num_int > 0)
free(integer_variables);
if (optimum_found) {
mpq_init(optimum);
ppl_Coefficient_to_mpz_t(optimum_n, tmp_z);
mpq_set_num(optimum, tmp_z);
ppl_Coefficient_to_mpz_t(optimum_d, tmp_z);
mpz_mul(tmp_z, tmp_z, den_lcm);
mpq_set_den(optimum, tmp_z);
if (verbosity == 1)
fprintf(output_file, "Optimized problem.\n");
if (verbosity >= 2)
fprintf(output_file, "Optimum value: %.10g\n", mpq_get_d(optimum));
if (verbosity >= 3) {
fprintf(output_file, "Optimum location:\n");
ppl_Generator_divisor(optimum_location, ppl_coeff);
ppl_Coefficient_to_mpz_t(ppl_coeff, tmp_z);
for (i = 0; i < dimension; ++i) {
mpz_set(mpq_denref(tmp1_q), tmp_z);
ppl_Generator_coefficient(optimum_location, i, ppl_coeff);
ppl_Coefficient_to_mpz_t(ppl_coeff, mpq_numref(tmp1_q));
ppl_io_fprint_variable(output_file, i);
fprintf(output_file, " = %.10g\n", mpq_get_d(tmp1_q));
}
}
#ifndef NDEBUG
{
ppl_Polyhedron_t ph;
unsigned int relation;
ppl_new_C_Polyhedron_recycle_Constraint_System(&ph, ppl_cs_copy);
ppl_delete_Constraint_System(ppl_cs_copy);
relation = ppl_Polyhedron_relation_with_Generator(ph, optimum_location);
ppl_delete_Polyhedron(ph);
assert(relation == PPL_POLY_GEN_RELATION_SUBSUMES);
}
#endif
maybe_check_results(PPL_MIP_PROBLEM_STATUS_OPTIMIZED,
mpq_get_d(optimum));
mpq_clear(optimum);
}
ppl_delete_Constraint_System(ppl_cs);
ppl_delete_Coefficient(optimum_d);
ppl_delete_Coefficient(optimum_n);
ppl_delete_Generator(optimum_location);
glp_delete_prob(glpk_lp);
}
ppl_Polyhedron_t
ppl_strip_loop (ppl_Polyhedron_t ph, ppl_dimension_type loop, int stride)
{
ppl_const_Constraint_System_t pcs;
ppl_Constraint_System_const_iterator_t cit, end;
ppl_const_Constraint_t cstr;
ppl_Linear_Expression_t expr;
int v;
ppl_dimension_type dim;
ppl_Polyhedron_t res;
ppl_Coefficient_t c;
Value val;
value_init (val);
ppl_new_Coefficient (&c);
ppl_Polyhedron_space_dimension (ph, &dim);
ppl_Polyhedron_get_constraints (ph, &pcs);
/* Start from a copy of the constraints. */
ppl_new_C_Polyhedron_from_space_dimension (&res, dim + 1, 0);
ppl_Polyhedron_add_constraints (res, pcs);
/* Add an empty dimension for the strip loop. */
ppl_insert_dimensions (res, loop, 1);
/* Identify the constraints that define the lower and upper bounds
of the strip-mined loop, and add them to the strip loop. */
{
ppl_Polyhedron_t tmp;
ppl_new_C_Polyhedron_from_space_dimension (&tmp, dim + 1, 0);
ppl_new_Constraint_System_const_iterator (&cit);
ppl_new_Constraint_System_const_iterator (&end);
for (ppl_Constraint_System_begin (pcs, cit),
ppl_Constraint_System_end (pcs, end);
!ppl_Constraint_System_const_iterator_equal_test (cit, end);
ppl_Constraint_System_const_iterator_increment (cit))
{
ppl_Constraint_System_const_iterator_dereference (cit, &cstr);
ppl_new_Linear_Expression_from_Constraint (&expr, cstr);
ppl_Linear_Expression_coefficient (expr, loop, c);
ppl_delete_Linear_Expression (expr);
ppl_Coefficient_to_mpz_t (c, val);
v = value_get_si (val);
if (0 < v || v < 0)
ppl_Polyhedron_add_constraint (tmp, cstr);
}
ppl_delete_Constraint_System_const_iterator (cit);
ppl_delete_Constraint_System_const_iterator (end);
ppl_insert_dimensions (tmp, loop + 1, 1);
ppl_Polyhedron_get_constraints (tmp, &pcs);
ppl_Polyhedron_add_constraints (res, pcs);
ppl_delete_Polyhedron (tmp);
}
/* Lower bound of a tile starts at "stride * outer_iv". */
{
ppl_Constraint_t new_cstr;
ppl_new_Linear_Expression_with_dimension (&expr, dim + 1);
ppl_set_coef (expr, loop + 1, 1);
ppl_set_coef (expr, loop, -1 * stride);
ppl_new_Constraint (&new_cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_delete_Linear_Expression (expr);
ppl_Polyhedron_add_constraint (res, new_cstr);
ppl_delete_Constraint (new_cstr);
}
/* Upper bound of a tile stops at "stride * outer_iv + stride - 1",
or at the old upper bound that is not modified. */
{
ppl_Constraint_t new_cstr;
ppl_new_Linear_Expression_with_dimension (&expr, dim + 1);
ppl_set_coef (expr, loop + 1, -1);
ppl_set_coef (expr, loop, stride);
ppl_set_inhomogeneous (expr, stride - 1);
ppl_new_Constraint (&new_cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_delete_Linear_Expression (expr);
ppl_Polyhedron_add_constraint (res, new_cstr);
ppl_delete_Constraint (new_cstr);
}
value_clear (val);
ppl_delete_Coefficient (c);
return res;
}
static bool
pbb_strip_mine_time_depth (poly_bb_p pbb, int time_depth, int stride)
{
ppl_dimension_type iter, dim, strip;
ppl_Polyhedron_t res = PBB_TRANSFORMED_SCATTERING (pbb);
/* STRIP is the dimension that iterates with stride STRIDE. */
/* ITER is the dimension that enumerates single iterations inside
one strip that has at most STRIDE iterations. */
strip = time_depth;
iter = strip + 2;
psct_add_scattering_dimension (pbb, strip);
psct_add_scattering_dimension (pbb, strip + 1);
ppl_Polyhedron_space_dimension (res, &dim);
/* Lower bound of the striped loop. */
{
ppl_Constraint_t new_cstr;
ppl_Linear_Expression_t expr;
ppl_new_Linear_Expression_with_dimension (&expr, dim);
ppl_set_coef (expr, strip, -1 * stride);
ppl_set_coef (expr, iter, 1);
ppl_new_Constraint (&new_cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_delete_Linear_Expression (expr);
ppl_Polyhedron_add_constraint (res, new_cstr);
ppl_delete_Constraint (new_cstr);
}
/* Upper bound of the striped loop. */
{
ppl_Constraint_t new_cstr;
ppl_Linear_Expression_t expr;
ppl_new_Linear_Expression_with_dimension (&expr, dim);
ppl_set_coef (expr, strip, stride);
ppl_set_coef (expr, iter, -1);
ppl_set_inhomogeneous (expr, stride - 1);
ppl_new_Constraint (&new_cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_delete_Linear_Expression (expr);
ppl_Polyhedron_add_constraint (res, new_cstr);
ppl_delete_Constraint (new_cstr);
}
/* Static scheduling for ITER level.
This is mandatory to keep the 2d + 1 canonical scheduling format. */
{
ppl_Constraint_t new_cstr;
ppl_Linear_Expression_t expr;
ppl_new_Linear_Expression_with_dimension (&expr, dim);
ppl_set_coef (expr, strip + 1, 1);
ppl_set_inhomogeneous (expr, 0);
ppl_new_Constraint (&new_cstr, expr, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_delete_Linear_Expression (expr);
ppl_Polyhedron_add_constraint (res, new_cstr);
ppl_delete_Constraint (new_cstr);
}
return true;
}
