/* Check if the constraints in "set" imply any stride on set dimension "pos" and
* store the results in data->stride and data->offset.
*
* In particular, compute the affine hull and then check if
* any of the constraints in the hull impose any stride on the dimension.
* If no such constraint can be found, then the offset is taken
* to be the zero expression and the stride is taken to be one.
*/
static void set_detect_stride(__isl_keep isl_set *set, int pos,
struct isl_detect_stride_data *data)
{
isl_basic_set *hull;
hull = isl_set_affine_hull(isl_set_copy(set));
data->pos = pos;
data->found = 0;
data->stride = NULL;
data->offset = NULL;
if (isl_basic_set_foreach_constraint(hull, &detect_stride, data) < 0)
goto error;
if (!data->found) {
data->stride = isl_val_one(isl_set_get_ctx(set));
if (data->want_offset) {
isl_space *space;
isl_local_space *ls;
space = isl_set_get_space(set);
ls = isl_local_space_from_space(space);
data->offset = isl_aff_zero_on_domain(ls);
}
}
isl_basic_set_free(hull);
return;
error:
isl_basic_set_free(hull);
data->stride = isl_val_free(data->stride);
data->offset = isl_aff_free(data->offset);
}
/* Check if the variable (e) at position level is defined by a
* pair of inequalities
* <a, i> + -m e + <b, p> + k1 >= 0
* <-a, i> + m e + <-b, p> + k2 >= 0
* with 0 <= k1 + k2 < m
* If so return the row number of the upper bound and set *lower
* to the row number of the lower bound. If not, return -1.
*
* If the variable at position level occurs in any other constraint,
* then we currently return -1. The modulo guard that we would generate
* would still be correct, but we would also need to generate
* guards corresponding to the other constraints, and this has not
* been implemented yet.
*/
CloogConstraint *cloog_constraint_set_defining_inequalities(
CloogConstraintSet *constraints,
int level, CloogConstraint **lower, int nb_par)
{
struct isl_constraint *u;
struct isl_constraint *l;
struct cloog_isl_dim dim;
struct isl_basic_set *bset;
struct cloog_isl_other other;
bset = cloog_constraints_set_to_isl(constraints);
dim = set_cloog_dim_to_isl_dim(constraints, level - 1);
if (!isl_basic_set_has_defining_inequalities(bset, dim.type, dim.pos,
&l, &u))
return cloog_constraint_invalid();
other.l = l;
other.u = u;
other.found = 0;
other.level = level;
isl_basic_set_foreach_constraint(bset, &check_other_constraint, &other);
if (other.found) {
isl_constraint_free(l);
isl_constraint_free(u);
*lower = NULL;
return NULL;
}
*lower = cloog_constraint_from_isl_constraint(l);
return cloog_constraint_from_isl_constraint(u);
}
/// Add an isl basic set to a ScopLib matrix_list
///
/// @param bset The basic set to add
/// @param user The matrix list we should add the basic set to
///
/// XXX: At the moment this function expects just a matrix, as support
/// for matrix lists is currently not available in ScopLib. So union of
/// polyhedron are not yet supported
int ScopLib::domainToMatrix_basic_set(isl_basic_set *bset, void *user) {
scoplib_matrix_p m = (scoplib_matrix_p) user;
assert(!m->NbRows && "Union of polyhedron not yet supported");
isl_basic_set_foreach_constraint(bset, &domainToMatrix_constraint, user);
isl_basic_set_free(bset);
return 0;
}
int cloog_constraint_set_foreach_constraint(CloogConstraintSet *constraints,
int (*fn)(CloogConstraint *constraint, void *user), void *user)
{
struct cloog_isl_foreach data = { fn, user };
isl_basic_set *bset;
bset = cloog_constraints_set_to_isl(constraints);
return isl_basic_set_foreach_constraint(bset,
cloog_isl_foreach_cb, &data);
}
