/* 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;
}
/* Merge the leaves at position "pos" and "pos + 1" in "leaves".
*/
static isl_stat merge_pair(int n, struct ppcg_grouping_leaf leaves[n], int pos)
{
int i;
leaves[pos].domain = isl_union_set_union(leaves[pos].domain,
leaves[pos + 1].domain);
leaves[pos].list = isl_union_set_list_concat(leaves[pos].list,
leaves[pos + 1].list);
leaves[pos].prefix = isl_multi_union_pw_aff_union_add(
leaves[pos].prefix, leaves[pos + 1].prefix);
for (i = pos + 1; i + 1 < n; ++i)
leaves[i] = leaves[i + 1];
leaves[n - 1].domain = NULL;
leaves[n - 1].list = NULL;
leaves[n - 1].prefix = NULL;
if (!leaves[pos].domain || !leaves[pos].list || !leaves[pos].prefix)
return isl_stat_error;
return isl_stat_ok;
}
/* Extend "grouping" with groups corresponding to merged
* leaves in the list of potentially merged leaves "leaves".
*
* The "list" field of each element in "leaves" contains a list
* of the instances sets of the original leaves that have been
* merged into this element. If at least two of the original leaves
* have been merged into a given element, then add the corresponding
* group to "grouping".
* In particular, the domain is extended with the statement instances
* of the merged leaves, the contraction is extended with a mapping
* of these statement instances to instances of a new group and
* the schedule is extended with a schedule that executes
* the statement instances according to the order of the leaves
* in which they appear.
* Since the instances of the groups should already be scheduled apart
* in the schedule into which this schedule will be plugged in,
* the schedules of the individual groups are combined independently
* of each other (as a set).
*/
static isl_stat add_groups(struct ppcg_grouping *grouping,
int n, struct ppcg_grouping_leaf leaves[n])
{
int i;
for (i = 0; i < n; ++i) {
int n_leaf;
isl_schedule *schedule;
isl_union_set *domain;
isl_union_pw_multi_aff *upma;
n_leaf = isl_union_set_list_n_union_set(leaves[i].list);
if (n_leaf < 0)
return isl_stat_error;
if (n_leaf <= 1)
continue;
schedule = schedule_from_domain_and_list(leaves[i].domain,
leaves[i].list);
upma = group_contraction_from_prefix_and_domain(grouping,
leaves[i].prefix, leaves[i].domain);
domain = isl_union_set_copy(leaves[i].domain);
if (grouping->domain) {
domain = isl_union_set_union(domain, grouping->domain);
upma = isl_union_pw_multi_aff_union_add(upma,
grouping->contraction);
schedule = isl_schedule_set(schedule,
grouping->schedule);
}
grouping->domain = domain;
grouping->contraction = upma;
grouping->schedule = schedule;
if (!grouping->domain || !grouping->contraction ||
!grouping->schedule)
return isl_stat_error;
}
return isl_stat_ok;
}
/* Complete "grouping" to cover all statement instances in the domain
* of grouping->sc.
*
* In particular, grouping->domain is set to the full set of statement
* instances; group->contraction is extended with an identity
* contraction on the additional instances and group->schedule
* is extended with an independent schedule on those additional instances.
* In the extension of group->contraction, the additional instances
* are split into those belong to different statements and those
* that belong to some of the same statements. The first group
* is replaced by its universe in order to simplify the contraction extension.
*/
static void complete_grouping(struct ppcg_grouping *grouping)
{
isl_union_set *domain, *left, *overlap;
isl_union_pw_multi_aff *upma;
isl_schedule *schedule;
domain = isl_schedule_constraints_get_domain(grouping->sc);
left = isl_union_set_subtract(isl_union_set_copy(domain),
isl_union_set_copy(grouping->domain));
schedule = isl_schedule_from_domain(isl_union_set_copy(left));
schedule = isl_schedule_set(schedule, grouping->schedule);
grouping->schedule = schedule;
overlap = isl_union_set_universe(grouping->domain);
grouping->domain = domain;
overlap = isl_union_set_intersect(isl_union_set_copy(left), overlap);
left = isl_union_set_subtract(left, isl_union_set_copy(overlap));
left = isl_union_set_universe(left);
left = isl_union_set_union(left, overlap);
upma = isl_union_set_identity_union_pw_multi_aff(left);
upma = isl_union_pw_multi_aff_union_add(upma, grouping->contraction);
grouping->contraction = upma;
}
static void *isl_obj_union_set_add(void *v1, void *v2)
{
return isl_union_set_union((isl_union_set *)v1, (isl_union_set *)v2);
}
