/* Extract a common guard from the grafts in "list" that can be hoisted
* out of the current level. If no such guard can be found, then return
* a universal set.
*
* If all the grafts in the list have the same guard and if this guard
* is independent of the current level, then it can be hoisted out.
* If there is only one graft in the list and if its guard
* depends on the current level, then we eliminate this level and
* return the result.
*
* Otherwise, we return the unshifted simple hull of the guards.
* In order to be able to hoist as many constraints as possible,
* but at the same time avoid hoisting constraints that did not
* appear in the guards in the first place, we intersect the guards
* with all the information that is available (i.e., the domain
* from the build and the enforced constraints of the graft) and
* compute the unshifted hull of the result using only constraints
* from the original guards.
* In particular, intersecting the guards with other known information
* allows us to hoist guards that are only explicit is some of
* the grafts and implicit in the others.
*
* The special case for equal guards is needed in case those guards
* are non-convex. Taking the simple hull would remove information
* and would not allow for these guards to be hoisted completely.
*/
__isl_give isl_set *isl_ast_graft_list_extract_hoistable_guard(
__isl_keep isl_ast_graft_list *list, __isl_keep isl_ast_build *build)
{
int i, n;
int equal;
isl_ctx *ctx;
isl_set *guard;
isl_set_list *set_list;
isl_basic_set *hull;
if (!list || !build)
return NULL;
n = isl_ast_graft_list_n_ast_graft(list);
if (n == 0)
return isl_set_universe(isl_ast_build_get_space(build, 1));
equal = equal_independent_guards(list, build);
if (equal < 0)
return NULL;
if (equal || n == 1) {
isl_ast_graft *graft_0;
graft_0 = isl_ast_graft_list_get_ast_graft(list, 0);
if (!graft_0)
return NULL;
guard = isl_set_copy(graft_0->guard);
if (!equal)
guard = hoist_guard(guard, build);
isl_ast_graft_free(graft_0);
return guard;
}
ctx = isl_ast_build_get_ctx(build);
set_list = isl_set_list_alloc(ctx, n);
guard = isl_set_empty(isl_ast_build_get_space(build, 1));
for (i = 0; i < n; ++i) {
isl_ast_graft *graft;
isl_basic_set *enforced;
isl_set *guard_i;
graft = isl_ast_graft_list_get_ast_graft(list, i);
enforced = isl_ast_graft_get_enforced(graft);
guard_i = isl_set_copy(graft->guard);
isl_ast_graft_free(graft);
set_list = isl_set_list_add(set_list, isl_set_copy(guard_i));
guard_i = isl_set_intersect(guard_i,
isl_set_from_basic_set(enforced));
guard_i = isl_set_intersect(guard_i,
isl_ast_build_get_domain(build));
guard = isl_set_union(guard, guard_i);
}
hull = isl_set_unshifted_simple_hull_from_set_list(guard, set_list);
guard = isl_set_from_basic_set(hull);
return hoist_guard(guard, build);
}
/* Extract a common guard from the grafts in "list" that can be hoisted
* out of the current level. If no such guard can be found, then return
* a universal set.
*
* If all the grafts in the list have the same guard and if this guard
* is independent of the current level, then it can be hoisted out.
* Otherwise, we return the unshifted simple hull of the guards.
*
* The special case for equal guards is needed in case those guards
* are non-convex. Taking the simple hull would remove information
* and would not allow for these guards to be hoisted completely.
*/
static __isl_give isl_set *extract_hoistable_guard(
__isl_keep isl_ast_graft_list *list, __isl_keep isl_ast_build *build)
{
int i, n;
int depth;
isl_ast_graft *graft_0;
int equal;
isl_set *guard;
if (!list || !build)
return NULL;
n = isl_ast_graft_list_n_ast_graft(list);
if (n == 0)
return isl_set_universe(isl_ast_build_get_space(build, 1));
equal = equal_independent_guards(list, build);
if (equal < 0)
return NULL;
graft_0 = isl_ast_graft_list_get_ast_graft(list, 0);
if (!graft_0)
return NULL;
guard = isl_set_copy(graft_0->guard);
isl_ast_graft_free(graft_0);
if (equal)
return guard;
depth = isl_ast_build_get_depth(build);
if (depth < isl_set_dim(guard, isl_dim_set)) {
guard = isl_set_remove_divs_involving_dims(guard,
isl_dim_set, depth, 1);
guard = isl_set_eliminate(guard, isl_dim_set, depth, 1);
guard = isl_set_compute_divs(guard);
}
for (i = 1; i < n; ++i) {
isl_ast_graft *graft;
isl_basic_set *hull;
int is_universe;
is_universe = isl_set_plain_is_universe(guard);
if (is_universe < 0)
guard = isl_set_free(guard);
if (is_universe)
break;
graft = isl_ast_graft_list_get_ast_graft(list, i);
if (!graft) {
guard = isl_set_free(guard);
break;
}
guard = isl_set_union(guard, isl_set_copy(graft->guard));
hull = isl_set_unshifted_simple_hull(guard);
guard = isl_set_from_basic_set(hull);
isl_ast_graft_free(graft);
}
return guard;
}
__isl_give isl_set *isl_set_box_from_points(__isl_take isl_point *pnt1,
__isl_take isl_point *pnt2)
{
isl_basic_set *bset;
bset = isl_basic_set_box_from_points(pnt1, pnt2);
return isl_set_from_basic_set(bset);
}
static int qpolynomial_bound_on_domain_range(__isl_take isl_basic_set *bset,
__isl_take isl_qpolynomial *poly, struct range_data *data)
{
unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
unsigned nvar = isl_basic_set_dim(bset, isl_dim_set);
isl_set *set = NULL;
if (!bset)
goto error;
if (nvar == 0)
return add_guarded_poly(bset, poly, data);
set = isl_set_from_basic_set(bset);
set = isl_set_split_dims(set, isl_dim_param, 0, nparam);
set = isl_set_split_dims(set, isl_dim_set, 0, nvar);
data->poly = poly;
data->test_monotonicity = 1;
if (isl_set_foreach_basic_set(set, &basic_guarded_poly_bound, data) < 0)
goto error;
isl_set_free(set);
isl_qpolynomial_free(poly);
return 0;
error:
isl_set_free(set);
isl_qpolynomial_free(poly);
return -1;
}
/* Insert an if node around a copy of "data->node" testing the condition
* encoded in guard "bset" and add the result to data->list.
*/
static int insert_if(__isl_take isl_basic_set *bset, void *user)
{
struct isl_insert_if_data *data = user;
isl_ast_node *node;
isl_set *set;
set = isl_set_from_basic_set(bset);
node = isl_ast_node_copy(data->node);
node = ast_node_insert_if(node, set, data->build);
data->list = isl_ast_node_list_add(data->list, node);
return 0;
}
/* Compute the union of all the constraints in domain. */
isl_union_set *nfm_union_domain_union_domains(isl_ctx *ctx,
struct nfm_union_domain *union_domain)
{
isl_union_set *union_set;
assert(union_domain);
assert(union_domain->domain);
IF_DEBUG(fprintf(stdout, " Starting the union function.\n"));
nfm_union_domain *head = union_domain;
union_set = isl_union_set_empty(nfm_domain_get_space(ctx, union_domain->domain));
IF_DEBUG(fprintf(stdout, " Initial value for the union set is:"));
IF_DEBUG(isl_union_set_dump(union_set));
while (head != NULL)
{
nfm_domain *domain = head->domain;
isl_bset_list *bset_list = nfm_domain_intersect_constraints(ctx, domain);
IF_DEBUG(fprintf(stdout, " The constraints at this iteration,"
" represented as a set, are:"));
IF_DEBUG(isl_bset_list_dump(bset_list));
while (bset_list != NULL)
{
union_set = isl_union_set_union(union_set,
isl_union_set_from_set(
isl_set_from_basic_set(
bset_list->bset)));
bset_list = bset_list->next;
}
IF_DEBUG(fprintf(stdout, " Results of the union:"));
IF_DEBUG(isl_union_set_dump(union_set));
head = head->next;
}
IF_DEBUG(fprintf(stdout, " End of the union function.\n"));
return union_set;
}
/* Helper function to add a guarded polynomial to either pwf_tight or pwf,
* depending on whether the result has been determined to be tight.
*/
static isl_stat add_guarded_poly(__isl_take isl_basic_set *bset,
__isl_take isl_qpolynomial *poly, struct range_data *data)
{
enum isl_fold type = data->sign < 0 ? isl_fold_min : isl_fold_max;
isl_set *set;
isl_qpolynomial_fold *fold;
isl_pw_qpolynomial_fold *pwf;
bset = isl_basic_set_params(bset);
poly = isl_qpolynomial_project_domain_on_params(poly);
fold = isl_qpolynomial_fold_alloc(type, poly);
set = isl_set_from_basic_set(bset);
pwf = isl_pw_qpolynomial_fold_alloc(type, set, fold);
if (data->tight)
data->pwf_tight = isl_pw_qpolynomial_fold_fold(
data->pwf_tight, pwf);
else
data->pwf = isl_pw_qpolynomial_fold_fold(data->pwf, pwf);
return isl_stat_ok;
}
__isl_give isl_set *isl_set_from_point(__isl_take isl_point *pnt)
{
isl_basic_set *bset;
bset = isl_basic_set_from_point(pnt);
return isl_set_from_basic_set(bset);
}
