/// @brief Create an isl constraint from a row of OpenScop integers.
///
/// @param row An array of isl/OpenScop integers.
/// @param Space An isl space object, describing how to spilt the dimensions.
///
/// @return An isl constraint representing this integer array.
isl_constraint *constraintFromMatrixRowFull(isl_int *row,
__isl_take isl_space *Space) {
isl_constraint *c;
unsigned NbOut = isl_space_dim(Space, isl_dim_out);
unsigned NbIn = isl_space_dim(Space, isl_dim_in);
unsigned NbParam = isl_space_dim(Space, isl_dim_param);
isl_local_space *LSpace = isl_local_space_from_space(Space);
if (isl_int_is_zero(row[0]))
c = isl_equality_alloc(LSpace);
else
c = isl_inequality_alloc(LSpace);
unsigned current_column = 1;
for (unsigned j = 0; j < NbOut; ++j)
isl_constraint_set_coefficient(c, isl_dim_out, j, row[current_column++]);
for (unsigned j = 0; j < NbIn; ++j)
isl_constraint_set_coefficient(c, isl_dim_in, j, row[current_column++]);
for (unsigned j = 0; j < NbParam; ++j)
isl_constraint_set_coefficient(c, isl_dim_param, j, row[current_column++]);
isl_constraint_set_constant(c, row[current_column]);
return c;
}
/// @brief Create an isl map from a OpenScop matrix.
///
/// @param m The OpenScop matrix to translate.
/// @param Space The dimensions that are contained in the OpenScop matrix.
///
/// @return An isl map representing m.
isl_map *mapFromMatrix(scoplib_matrix_p m, __isl_take isl_space *Space,
unsigned scatteringDims) {
isl_basic_map *bmap = isl_basic_map_universe(isl_space_copy(Space));
for (unsigned i = 0; i < m->NbRows; ++i) {
isl_constraint *c;
c = constraintFromMatrixRow(m->p[i], isl_space_copy(Space));
mpz_t minusOne;
mpz_init(minusOne);
mpz_set_si(minusOne, -1);
isl_constraint_set_coefficient(c, isl_dim_out, i, minusOne);
bmap = isl_basic_map_add_constraint(bmap, c);
}
for (unsigned i = m->NbRows; i < scatteringDims; i++) {
isl_constraint *c;
c = isl_equality_alloc(isl_local_space_from_space(isl_space_copy(Space)));
mpz_t One;
mpz_init(One);
mpz_set_si(One, 1);
isl_constraint_set_coefficient(c, isl_dim_out, i, One);
bmap = isl_basic_map_add_constraint(bmap, c);
}
isl_space_free(Space);
return isl_map_from_basic_map(bmap);
}
static
isl_map* build_access_function (scoplib_scop_p scop,
scoplib_statement_p s,
scoplib_matrix_p m,
isl_space* space,
isl_ctx* ctxt,
int* row_pos,
int array_id)
{
isl_map* ret = NULL;
int i;
isl_val* tmp = isl_val_int_from_si (ctxt, 0);
for (i = *row_pos; i < m->NbRows; ++i)
{
if (SCOPVAL_get_si(m->p[i][0]) == array_id)
{
ret = isl_map_universe (isl_space_copy (space));
int pos = 0;
do
{
isl_local_space* ls =
isl_local_space_from_space (isl_space_copy (space));
isl_constraint* cst = isl_equality_alloc (isl_local_space_copy (ls));
// Set input dimensions.
int k;
for (k = 0; k < s->nb_iterators; ++k)
{
tmp = isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][k+1]));
cst = isl_constraint_set_coefficient_val (cst, isl_dim_in, k, isl_val_copy(tmp));
}
for (k = 0; k < scop->nb_parameters; ++k)
{
tmp =
isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][k+1+s->nb_iterators]));
cst =
isl_constraint_set_coefficient_val (cst, isl_dim_param, k,
isl_val_copy (tmp));
}
tmp = isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][m->NbColumns - 1]));
cst = isl_constraint_set_constant_val (cst, isl_val_copy(tmp));
// Set output dimension.
tmp = isl_val_set_si (tmp, -1);
isl_constraint_set_coefficient_val (cst, isl_dim_out, pos++, isl_val_copy (tmp));
// Insert constraint.
ret = isl_map_add_constraint (ret, cst);
++i;
}
while (i < m->NbRows && SCOPVAL_get_si(m->p[i][0]) == 0);
*row_pos = i;
break;
}
}
isl_val_free (tmp);
return ret;
}
static
isl_set* build_iteration_domain (scoplib_scop_p scop,
scoplib_statement_p s,
isl_space* space,
isl_ctx* ctxt)
{
isl_set* ret = isl_set_universe (isl_space_domain (isl_space_copy (space)));
int i;
isl_val* tmp = isl_val_int_from_si (ctxt, 0);
scoplib_matrix_p m = s->domain->elt;
for (i = 0; i < m->NbRows; ++i)
{
isl_local_space* ls =
isl_local_space_from_space (isl_set_get_space (ret));
isl_constraint* cst;
if (SCOPVAL_get_si(m->p[i][0]) == 0)
cst = isl_equality_alloc (isl_local_space_copy (ls));
else
cst = isl_inequality_alloc (isl_local_space_copy (ls));
// Set input dimensions.
int k;
for (k = 0; k < s->nb_iterators; ++k)
{
tmp = isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][k+1]));
cst = isl_constraint_set_coefficient_val (cst, isl_dim_set, k, isl_val_copy (tmp));
}
for (k = 0; k < scop->nb_parameters; ++k)
{
tmp =
isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][k+1+s->nb_iterators]));
cst =
isl_constraint_set_coefficient_val (cst, isl_dim_param, k,
isl_val_copy (tmp));
}
tmp = isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][m->NbColumns - 1]));
cst = isl_constraint_set_constant_val (cst, isl_val_copy (tmp));
// Insert constraint.
ret = isl_set_add_constraint (ret, cst);
}
isl_val_free (tmp);
return ret;
}
static isl_constraint *
build_linearized_memory_access (isl_map *map, poly_dr_p pdr)
{
isl_constraint *res;
isl_local_space *ls = isl_local_space_from_space (isl_map_get_space (map));
unsigned offset, nsubs;
int i;
isl_int size, subsize;
res = isl_equality_alloc (ls);
isl_int_init (size);
isl_int_set_ui (size, 1);
isl_int_init (subsize);
isl_int_set_ui (subsize, 1);
nsubs = isl_set_dim (pdr->extent, isl_dim_set);
/* -1 for the already included L dimension. */
offset = isl_map_dim (map, isl_dim_out) - 1 - nsubs;
res = isl_constraint_set_coefficient_si (res, isl_dim_out, offset + nsubs, -1);
/* Go through all subscripts from last to first. First dimension
is the alias set, ignore it. */
for (i = nsubs - 1; i >= 1; i--)
{
isl_space *dc;
isl_aff *aff;
res = isl_constraint_set_coefficient (res, isl_dim_out, offset + i, size);
dc = isl_set_get_space (pdr->extent);
aff = isl_aff_zero_on_domain (isl_local_space_from_space (dc));
aff = isl_aff_set_coefficient_si (aff, isl_dim_in, i, 1);
isl_set_max (pdr->extent, aff, &subsize);
isl_aff_free (aff);
isl_int_mul (size, size, subsize);
}
isl_int_clear (subsize);
isl_int_clear (size);
return res;
}
static void
pbb_strip_mine_time_depth (poly_bb_p pbb, int time_depth, int stride)
{
isl_space *d;
isl_constraint *c;
int iter, strip;
/* 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;
pbb->transformed = isl_map_insert_dims (pbb->transformed, isl_dim_out,
strip, 2);
/* Lower bound of the striped loop. */
d = isl_map_get_space (pbb->transformed);
c = isl_inequality_alloc (isl_local_space_from_space (d));
c = isl_constraint_set_coefficient_si (c, isl_dim_out, strip, -stride);
c = isl_constraint_set_coefficient_si (c, isl_dim_out, iter, 1);
pbb->transformed = isl_map_add_constraint (pbb->transformed, c);
/* Upper bound of the striped loop. */
d = isl_map_get_space (pbb->transformed);
c = isl_inequality_alloc (isl_local_space_from_space (d));
c = isl_constraint_set_coefficient_si (c, isl_dim_out, strip, stride);
c = isl_constraint_set_coefficient_si (c, isl_dim_out, iter, -1);
c = isl_constraint_set_constant_si (c, stride - 1);
pbb->transformed = isl_map_add_constraint (pbb->transformed, c);
/* Static scheduling for ITER level.
This is mandatory to keep the 2d + 1 canonical scheduling format. */
d = isl_map_get_space (pbb->transformed);
c = isl_equality_alloc (isl_local_space_from_space (d));
c = isl_constraint_set_coefficient_si (c, isl_dim_out, strip + 1, 1);
pbb->transformed = isl_map_add_constraint (pbb->transformed, c);
}
static void
pdr_stride_in_loop (mpz_t stride, graphite_dim_t depth, poly_dr_p pdr)
{
poly_bb_p pbb = PDR_PBB (pdr);
isl_map *map;
isl_set *set;
isl_aff *aff;
isl_space *dc;
isl_constraint *lma, *c;
isl_int islstride;
graphite_dim_t time_depth;
unsigned offset, nt;
unsigned i;
/* XXX isl rewrite following comments. */
/* Builds a partial difference equations and inserts them
into pointset powerset polyhedron P. Polyhedron is assumed
to have the format: T|I|T'|I'|G|S|S'|l1|l2.
TIME_DEPTH is the time dimension w.r.t. which we are
differentiating.
OFFSET represents the number of dimensions between
columns t_{time_depth} and t'_{time_depth}.
DIM_SCTR is the number of scattering dimensions. It is
essentially the dimensionality of the T vector.
The following equations are inserted into the polyhedron P:
| t_1 = t_1'
| ...
| t_{time_depth-1} = t'_{time_depth-1}
| t_{time_depth} = t'_{time_depth} + 1
| t_{time_depth+1} = t'_{time_depth + 1}
| ...
| t_{dim_sctr} = t'_{dim_sctr}. */
/* Add the equality: t_{time_depth} = t'_{time_depth} + 1.
This is the core part of this alogrithm, since this
constraint asks for the memory access stride (difference)
between two consecutive points in time dimensions. */
/* Add equalities:
| t1 = t1'
| ...
| t_{time_depth-1} = t'_{time_depth-1}
| t_{time_depth+1} = t'_{time_depth+1}
| ...
| t_{dim_sctr} = t'_{dim_sctr}
This means that all the time dimensions are equal except for
time_depth, where the constraint is t_{depth} = t'_{depth} + 1
step. More to this: we should be careful not to add equalities
to the 'coupled' dimensions, which happens when the one dimension
is stripmined dimension, and the other dimension corresponds
to the point loop inside stripmined dimension. */
/* pdr->accesses: [P1..nb_param,I1..nb_domain]->[a,S1..nb_subscript]
??? [P] not used for PDRs?
pdr->extent: [a,S1..nb_subscript]
pbb->domain: [P1..nb_param,I1..nb_domain]
pbb->transformed: [P1..nb_param,I1..nb_domain]->[T1..Tnb_sctr]
[T] includes local vars (currently unused)
First we create [P,I] -> [T,a,S]. */
map = isl_map_flat_range_product (isl_map_copy (pbb->transformed),
isl_map_copy (pdr->accesses));
/* Add a dimension for L: [P,I] -> [T,a,S,L].*/
map = isl_map_add_dims (map, isl_dim_out, 1);
/* Build a constraint for "lma[S] - L == 0", effectively calculating
L in terms of subscripts. */
lma = build_linearized_memory_access (map, pdr);
/* And add it to the map, so we now have:
[P,I] -> [T,a,S,L] : lma([S]) == L. */
map = isl_map_add_constraint (map, lma);
/* Then we create [P,I,P',I'] -> [T,a,S,L,T',a',S',L']. */
map = isl_map_flat_product (map, isl_map_copy (map));
/* Now add the equality T[time_depth] == T'[time_depth]+1. This will
force L' to be the linear address at T[time_depth] + 1. */
time_depth = psct_dynamic_dim (pbb, depth);
/* Length of [a,S] plus [L] ... */
offset = 1 + isl_map_dim (pdr->accesses, isl_dim_out);
/* ... plus [T]. */
offset += isl_map_dim (pbb->transformed, isl_dim_out);
c = isl_equality_alloc (isl_local_space_from_space (isl_map_get_space (map)));
c = isl_constraint_set_coefficient_si (c, isl_dim_out, time_depth, 1);
c = isl_constraint_set_coefficient_si (c, isl_dim_out,
offset + time_depth, -1);
c = isl_constraint_set_constant_si (c, 1);
map = isl_map_add_constraint (map, c);
/* Now we equate most of the T/T' elements (making PITaSL nearly
the same is (PITaSL)', except for one dimension, namely for 'depth'
(an index into [I]), after translating to index into [T]. Take care
to not produce an empty map, which indicates we wanted to equate
two dimensions that are already coupled via the above time_depth
dimension. Happens with strip mining where several scatter dimension
are interdependend. */
/* Length of [T]. */
nt = pbb_nb_scattering_transform (pbb) + pbb_nb_local_vars (pbb);
for (i = 0; i < nt; i++)
if (i != time_depth)
{
isl_map *temp = isl_map_equate (isl_map_copy (map),
isl_dim_out, i,
isl_dim_out, offset + i);
if (isl_map_is_empty (temp))
isl_map_free (temp);
else
{
isl_map_free (map);
map = temp;
}
}
/* Now maximize the expression L' - L. */
set = isl_map_range (map);
dc = isl_set_get_space (set);
aff = isl_aff_zero_on_domain (isl_local_space_from_space (dc));
aff = isl_aff_set_coefficient_si (aff, isl_dim_in, offset - 1, -1);
aff = isl_aff_set_coefficient_si (aff, isl_dim_in, offset + offset - 1, 1);
isl_int_init (islstride);
isl_set_max (set, aff, &islstride);
isl_int_get_gmp (islstride, stride);
isl_int_clear (islstride);
isl_aff_free (aff);
isl_set_free (set);
if (dump_file && (dump_flags & TDF_DETAILS))
{
char *str;
void (*gmp_free) (void *, size_t);
fprintf (dump_file, "\nStride in BB_%d, DR_%d, depth %d:",
pbb_index (pbb), PDR_ID (pdr), (int) depth);
str = mpz_get_str (0, 10, stride);
fprintf (dump_file, " %s ", str);
mp_get_memory_functions (NULL, NULL, &gmp_free);
(*gmp_free) (str, strlen (str) + 1);
}
}
/**
* Reduce the modulo guard expressed by "constraints" using equalities
* found in outer nesting levels (stored in "equal").
* The modulo guard may be an equality or a pair of inequalities.
* In case of a pair of inequalities, *bound contains the bound on the
* corresponding modulo expression. If any reduction is performed
* then this bound is recomputed.
*
* "level" may not correspond to an existentially quantified variable.
*
* We first check if there are any equalities we can use. If not,
* there is again nothing to reduce.
* For the actual reduction, we use isl_basic_set_gist, but this
* function will only perform the reduction we want here if the
* the variable that imposes the modulo constraint has been projected
* out (i.e., turned into an existentially quantified variable).
* After the call to isl_basic_set_gist, we need to move the
* existential variable back into the position where the calling
* function expects it (assuming there are any constraints left).
* We do this by adding an equality between the given dimension and
* the existentially quantified variable.
*
* If there are no existentially quantified variables left, then
* we don't need to add this equality.
* If, on the other hand, the resulting basic set involves more
* than one existentially quantified variable, then the caller
* will not be able to handle the result, so we just return the
* original input instead.
*/
CloogConstraintSet *cloog_constraint_set_reduce(CloogConstraintSet *constraints,
int level, CloogEqualities *equal, int nb_par, cloog_int_t *bound)
{
int j;
isl_space *idim;
struct isl_basic_set *eq;
struct isl_basic_map *id;
struct cloog_isl_dim dim;
struct isl_constraint *c;
unsigned constraints_dim;
unsigned n_div;
isl_basic_set *bset, *orig;
bset = cloog_constraints_set_to_isl(constraints);
orig = isl_basic_set_copy(bset);
dim = set_cloog_dim_to_isl_dim(constraints, level - 1);
assert(dim.type == isl_dim_set);
eq = NULL;
for (j = 0; j < level - 1; ++j) {
isl_basic_set *bset_j;
if (equal->types[j] != EQTYPE_EXAFFINE)
continue;
bset_j = equality_to_basic_set(equal, j);
if (!eq)
eq = bset_j;
else
eq = isl_basic_set_intersect(eq, bset_j);
}
if (!eq) {
isl_basic_set_free(orig);
return cloog_constraint_set_from_isl_basic_set(bset);
}
idim = isl_space_map_from_set(isl_basic_set_get_space(bset));
id = isl_basic_map_identity(idim);
id = isl_basic_map_remove_dims(id, isl_dim_out, dim.pos, 1);
bset = isl_basic_set_apply(bset, isl_basic_map_copy(id));
bset = isl_basic_set_apply(bset, isl_basic_map_reverse(id));
constraints_dim = isl_basic_set_dim(bset, isl_dim_set);
eq = isl_basic_set_remove_dims(eq, isl_dim_set, constraints_dim,
isl_basic_set_dim(eq, isl_dim_set) - constraints_dim);
bset = isl_basic_set_gist(bset, eq);
n_div = isl_basic_set_dim(bset, isl_dim_div);
if (n_div > 1) {
isl_basic_set_free(bset);
return cloog_constraint_set_from_isl_basic_set(orig);
}
if (n_div < 1) {
isl_basic_set_free(orig);
return cloog_constraint_set_from_isl_basic_set(bset);
}
c = isl_equality_alloc(isl_basic_set_get_local_space(bset));
c = isl_constraint_set_coefficient_si(c, isl_dim_div, 0, 1);
c = isl_constraint_set_coefficient_si(c, isl_dim_set, dim.pos, -1);
bset = isl_basic_set_add_constraint(bset, c);
isl_int_set_si(*bound, 0);
constraints = cloog_constraint_set_from_isl_basic_set(bset);
cloog_constraint_set_foreach_constraint(constraints,
add_constant_term, bound);
isl_basic_set_free(orig);
return cloog_constraint_set_from_isl_basic_set(bset);
}
static
isl_map* build_schedule (scoplib_scop_p scop,
scoplib_statement_p s,
isl_space* sp,
isl_ctx* ctxt)
{
// Set up the space.
isl_space* space_in = isl_space_domain (isl_space_copy (sp));
int dout = s->schedule->NbRows;
isl_space* space_out = isl_space_set_alloc(ctxt, scop->nb_parameters, dout);
int i;
char buffer[32];
char* name;
for (i = 0; i < dout; ++i)
{
sprintf (buffer, "t%d", i);
name = strdup (buffer);
space_out = isl_space_set_dim_name (space_out, isl_dim_set, i, name);
}
for (i = 0; i < scop->nb_parameters; ++i)
{
name = strdup (((SgVariableSymbol*)(scop->parameters[i]))->get_name().str());
space_out = isl_space_set_dim_name (space_out, isl_dim_param, i, name);
}
isl_space* space = isl_space_map_from_domain_and_range
(isl_space_copy (space_in), isl_space_copy (space_out));
isl_map* ret = isl_map_universe (isl_space_copy (space));
isl_val* tmp = isl_val_int_from_si (ctxt, 0);
scoplib_matrix_p m = s->schedule;
for (i = 0; i < m->NbRows; ++i)
{
isl_local_space* ls =
isl_local_space_from_space (isl_space_copy (space));
isl_constraint* cst;
if (SCOPVAL_get_si(m->p[i][0]) == 0)
cst = isl_equality_alloc (isl_local_space_copy (ls));
else
cst = isl_inequality_alloc (isl_local_space_copy (ls));
// Set input dimensions.
int k;
for (k = 0; k < s->nb_iterators; ++k)
{
tmp = isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][k+1]));
cst = isl_constraint_set_coefficient_val (cst, isl_dim_in, k, isl_val_copy (tmp));
}
for (k = 0; k < scop->nb_parameters; ++k)
{
tmp =
isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][k+1+s->nb_iterators]));
cst =
isl_constraint_set_coefficient_val (cst, isl_dim_param, k,
isl_val_copy (tmp));
}
tmp = isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][m->NbColumns - 1]));
cst = isl_constraint_set_constant_val (cst, isl_val_copy (tmp));
// Set output dimension.
tmp = isl_val_set_si (tmp, -1);
isl_constraint_set_coefficient_val (cst, isl_dim_out, i, isl_val_copy (tmp));
// Insert constraint.
ret = isl_map_add_constraint (ret, cst);
}
isl_val_free (tmp);
return ret;
}
void equality (const std::vector< int > & coeffs) {
isl_constraint * equ = isl_equality_alloc (isl_local_space_copy (ls));
for (unsigned c = 0; c < coeffs.size (); ++c)
equ = isl_constraint_set_coefficient_si (equ, isl_dim_set, c, coeffs[c]);
solutions = isl_set_add_constraint (solutions, equ);
}