/* Given a stride constraint on iterator i (specified by level) of the form
*
* i = f(outer iterators) + stride * f(existentials)
*
* extract f as an isl_aff.
*/
static isl_aff *extract_stride_offset(__isl_keep isl_constraint *c,
int level, CloogStride *stride)
{
int i;
isl_space *dim = isl_constraint_get_space(c);
isl_local_space *ls = isl_local_space_from_space(dim);
isl_aff *offset = isl_aff_zero_on_domain(ls);
isl_int u;
unsigned nparam, nvar;
isl_int_init(u);
nparam = isl_constraint_dim(c, isl_dim_param);
nvar = isl_constraint_dim(c, isl_dim_set);
for (i = 0; i < nparam; ++i) {
isl_constraint_get_coefficient(c, isl_dim_param, i, &u);
isl_int_mul(u, u, stride->factor);
offset = isl_aff_set_coefficient(offset, isl_dim_param, i, u);
}
for (i = 0; i < nvar; ++i) {
if (i == level - 1)
continue;
isl_constraint_get_coefficient(c, isl_dim_set, i, &u);
isl_int_mul(u, u, stride->factor);
offset = isl_aff_set_coefficient(offset, isl_dim_in, i, u);
}
isl_constraint_get_constant(c, &u);
isl_int_mul(u, u, stride->factor);
offset = isl_aff_set_constant(offset, u);
isl_int_clear(u);
return offset;
}
/**
* cloog_constraint_equal_type function :
* This function returns the type of the equality in the constraint (line) of
* (constraints) for the element (level). An equality is 'constant' iff all
* other factors are null except the constant one. It is a 'pure item' iff
* it is equal or opposite to a single variable or parameter.
* Otherwise it is an 'affine expression'.
* For instance:
* i = -13 is constant, i = j, j = -M are pure items,
* j = 2*M, i = j+1, 2*j = M are affine expressions.
*
* - constraints is the matrix of constraints,
* - level is the column number in equal of the element which is 'equal to',
*/
static int cloog_constraint_equal_type(CloogConstraint *cc, int level)
{
int i;
isl_int c;
int type = EQTYPE_NONE;
struct isl_constraint *constraint = cloog_constraint_to_isl(cc);
isl_int_init(c);
isl_constraint_get_constant(constraint, &c);
if (!isl_int_is_zero(c))
type = EQTYPE_CONSTANT;
isl_constraint_get_coefficient(constraint, isl_dim_set, level - 1, &c);
if (!isl_int_is_one(c) && !isl_int_is_negone(c))
type = EQTYPE_EXAFFINE;
for (i = 0; i < isl_constraint_dim(constraint, isl_dim_param); ++i) {
isl_constraint_get_coefficient(constraint, isl_dim_param, i, &c);
if (isl_int_is_zero(c))
continue;
if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
type != EQTYPE_NONE) {
type = EQTYPE_EXAFFINE;
break;
}
type = EQTYPE_PUREITEM;
}
for (i = 0; i < isl_constraint_dim(constraint, isl_dim_set); ++i) {
if (i == level - 1)
continue;
isl_constraint_get_coefficient(constraint, isl_dim_set, i, &c);
if (isl_int_is_zero(c))
continue;
if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
type != EQTYPE_NONE) {
type = EQTYPE_EXAFFINE;
break;
}
type = EQTYPE_PUREITEM;
}
for (i = 0; i < isl_constraint_dim(constraint, isl_dim_div); ++i) {
isl_constraint_get_coefficient(constraint, isl_dim_div, i, &c);
if (isl_int_is_zero(c))
continue;
if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
type != EQTYPE_NONE) {
type = EQTYPE_EXAFFINE;
break;
}
type = EQTYPE_PUREITEM;
}
isl_int_clear(c);
if (type == EQTYPE_NONE)
type = EQTYPE_CONSTANT;
return type;
}
/// Add an isl constraint to an ScopLib matrix.
///
/// @param user The matrix
/// @param c The constraint
int ScopLib::accessToMatrix_constraint(isl_constraint *c, void *user) {
scoplib_matrix_p m = (scoplib_matrix_p) user;
int nb_params = isl_constraint_dim(c, isl_dim_param);
int nb_in = isl_constraint_dim(c, isl_dim_in);
int nb_div = isl_constraint_dim(c, isl_dim_div);
assert(!nb_div && "Existentially quantified variables not yet supported");
scoplib_vector_p vec =
scoplib_vector_malloc(nb_params + nb_in + 2);
isl_int v;
isl_int_init(v);
// The access dimension has to be one.
isl_constraint_get_coefficient(c, isl_dim_out, 0, &v);
assert((isl_int_is_one(v) || isl_int_is_negone(v))
&& "Access relations not supported in scoplib");
bool inverse = isl_int_is_one(v);
// Assign variables
for (int i = 0; i < nb_in; ++i) {
isl_constraint_get_coefficient(c, isl_dim_in, i, &v);
if (inverse) isl_int_neg(v,v);
isl_int_set(vec->p[i + 1], v);
}
// Assign parameters
for (int i = 0; i < nb_params; ++i) {
isl_constraint_get_coefficient(c, isl_dim_param, i, &v);
if (inverse) isl_int_neg(v,v);
isl_int_set(vec->p[nb_in + i + 1], v);
}
// Assign constant
isl_constraint_get_constant(c, &v);
if (inverse) isl_int_neg(v,v);
isl_int_set(vec->p[nb_in + nb_params + 1], v);
scoplib_matrix_insert_vector(m, vec, m->NbRows);
isl_constraint_free(c);
isl_int_clear(v);
return 0;
}
/// Add an isl constraint to an ScopLib matrix.
///
/// @param user The matrix
/// @param c The constraint
int ScopLib::scatteringToMatrix_constraint(isl_constraint *c, void *user) {
scoplib_matrix_p m = (scoplib_matrix_p) user;
int nb_params = isl_constraint_dim(c, isl_dim_param);
int nb_in = isl_constraint_dim(c, isl_dim_in);
int nb_div = isl_constraint_dim(c, isl_dim_div);
assert(!nb_div && "Existentially quantified variables not yet supported");
scoplib_vector_p vec =
scoplib_vector_malloc(nb_params + nb_in + 2);
// Assign type
if (isl_constraint_is_equality(c))
scoplib_vector_tag_equality(vec);
else
scoplib_vector_tag_inequality(vec);
isl_int v;
isl_int_init(v);
// Assign variables
for (int i = 0; i < nb_in; ++i) {
isl_constraint_get_coefficient(c, isl_dim_in, i, &v);
isl_int_set(vec->p[i + 1], v);
}
// Assign parameters
for (int i = 0; i < nb_params; ++i) {
isl_constraint_get_coefficient(c, isl_dim_param, i, &v);
isl_int_set(vec->p[nb_in + i + 1], v);
}
// Assign constant
isl_constraint_get_constant(c, &v);
isl_int_set(vec->p[nb_in + nb_params + 1], v);
scoplib_vector_p null =
scoplib_vector_malloc(nb_params + nb_in + 2);
vec = scoplib_vector_sub(null, vec);
scoplib_matrix_insert_vector(m, vec, 0);
isl_constraint_free(c);
isl_int_clear(v);
return 0;
}
void cloog_constraint_constant_get(CloogConstraint *constraint, cloog_int_t *val)
{
isl_constraint_get_constant(cloog_constraint_to_isl(constraint), val);
}