/* 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); }