2 * Copyright 2010 INRIA Saclay
4 * Use of this software is governed by the GNU LGPLv2.1 license
6 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
7 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
12 #include "isl_map_private.h"
14 #include <isl_dim_private.h>
16 #include <isl_union_map.h>
18 int isl_map_is_transitively_closed(__isl_keep isl_map
*map
)
23 map2
= isl_map_apply_range(isl_map_copy(map
), isl_map_copy(map
));
24 closed
= isl_map_is_subset(map2
, map
);
30 int isl_union_map_is_transitively_closed(__isl_keep isl_union_map
*umap
)
35 umap2
= isl_union_map_apply_range(isl_union_map_copy(umap
),
36 isl_union_map_copy(umap
));
37 closed
= isl_union_map_is_subset(umap2
, umap
);
38 isl_union_map_free(umap2
);
43 /* Given a map that represents a path with the length of the path
44 * encoded as the difference between the last output coordindate
45 * and the last input coordinate, set this length to either
46 * exactly "length" (if "exactly" is set) or at least "length"
47 * (if "exactly" is not set).
49 static __isl_give isl_map
*set_path_length(__isl_take isl_map
*map
,
50 int exactly
, int length
)
53 struct isl_basic_map
*bmap
;
62 dim
= isl_map_get_dim(map
);
63 d
= isl_dim_size(dim
, isl_dim_in
);
64 nparam
= isl_dim_size(dim
, isl_dim_param
);
65 bmap
= isl_basic_map_alloc_dim(dim
, 0, 1, 1);
67 k
= isl_basic_map_alloc_equality(bmap
);
70 k
= isl_basic_map_alloc_inequality(bmap
);
75 isl_seq_clr(c
, 1 + isl_basic_map_total_dim(bmap
));
76 isl_int_set_si(c
[0], -length
);
77 isl_int_set_si(c
[1 + nparam
+ d
- 1], -1);
78 isl_int_set_si(c
[1 + nparam
+ d
+ d
- 1], 1);
80 bmap
= isl_basic_map_finalize(bmap
);
81 map
= isl_map_intersect(map
, isl_map_from_basic_map(bmap
));
85 isl_basic_map_free(bmap
);
90 /* Check whether the overapproximation of the power of "map" is exactly
91 * the power of "map". Let R be "map" and A_k the overapproximation.
92 * The approximation is exact if
95 * A_k = A_{k-1} \circ R k >= 2
97 * Since A_k is known to be an overapproximation, we only need to check
100 * A_k \subset A_{k-1} \circ R k >= 2
102 * In practice, "app" has an extra input and output coordinate
103 * to encode the length of the path. So, we first need to add
104 * this coordinate to "map" and set the length of the path to
107 static int check_power_exactness(__isl_take isl_map
*map
,
108 __isl_take isl_map
*app
)
114 map
= isl_map_add(map
, isl_dim_in
, 1);
115 map
= isl_map_add(map
, isl_dim_out
, 1);
116 map
= set_path_length(map
, 1, 1);
118 app_1
= set_path_length(isl_map_copy(app
), 1, 1);
120 exact
= isl_map_is_subset(app_1
, map
);
123 if (!exact
|| exact
< 0) {
129 app_1
= set_path_length(isl_map_copy(app
), 0, 1);
130 app_2
= set_path_length(app
, 0, 2);
131 app_1
= isl_map_apply_range(map
, app_1
);
133 exact
= isl_map_is_subset(app_2
, app_1
);
141 /* Check whether the overapproximation of the power of "map" is exactly
142 * the power of "map", possibly after projecting out the power (if "project"
145 * If "project" is set and if "steps" can only result in acyclic paths,
148 * A = R \cup (A \circ R)
150 * where A is the overapproximation with the power projected out, i.e.,
151 * an overapproximation of the transitive closure.
152 * More specifically, since A is known to be an overapproximation, we check
154 * A \subset R \cup (A \circ R)
156 * Otherwise, we check if the power is exact.
158 * Note that "app" has an extra input and output coordinate to encode
159 * the length of the part. If we are only interested in the transitive
160 * closure, then we can simply project out these coordinates first.
162 static int check_exactness(__isl_take isl_map
*map
, __isl_take isl_map
*app
,
170 return check_power_exactness(map
, app
);
172 d
= isl_map_dim(map
, isl_dim_in
);
173 app
= set_path_length(app
, 0, 1);
174 app
= isl_map_project_out(app
, isl_dim_in
, d
, 1);
175 app
= isl_map_project_out(app
, isl_dim_out
, d
, 1);
177 app
= isl_map_reset_dim(app
, isl_map_get_dim(map
));
179 test
= isl_map_apply_range(isl_map_copy(map
), isl_map_copy(app
));
180 test
= isl_map_union(test
, isl_map_copy(map
));
182 exact
= isl_map_is_subset(app
, test
);
193 * The transitive closure implementation is based on the paper
194 * "Computing the Transitive Closure of a Union of Affine Integer
195 * Tuple Relations" by Anna Beletska, Denis Barthou, Wlodzimierz Bielecki and
199 /* Given a set of n offsets v_i (the rows of "steps"), construct a relation
200 * of the given dimension specification (Z^{n+1} -> Z^{n+1})
201 * that maps an element x to any element that can be reached
202 * by taking a non-negative number of steps along any of
203 * the extended offsets v'_i = [v_i 1].
206 * { [x] -> [y] : exists k_i >= 0, y = x + \sum_i k_i v'_i }
208 * For any element in this relation, the number of steps taken
209 * is equal to the difference in the final coordinates.
211 static __isl_give isl_map
*path_along_steps(__isl_take isl_dim
*dim
,
212 __isl_keep isl_mat
*steps
)
215 struct isl_basic_map
*path
= NULL
;
223 d
= isl_dim_size(dim
, isl_dim_in
);
225 nparam
= isl_dim_size(dim
, isl_dim_param
);
227 path
= isl_basic_map_alloc_dim(isl_dim_copy(dim
), n
, d
, n
);
229 for (i
= 0; i
< n
; ++i
) {
230 k
= isl_basic_map_alloc_div(path
);
233 isl_assert(steps
->ctx
, i
== k
, goto error
);
234 isl_int_set_si(path
->div
[k
][0], 0);
237 for (i
= 0; i
< d
; ++i
) {
238 k
= isl_basic_map_alloc_equality(path
);
241 isl_seq_clr(path
->eq
[k
], 1 + isl_basic_map_total_dim(path
));
242 isl_int_set_si(path
->eq
[k
][1 + nparam
+ i
], 1);
243 isl_int_set_si(path
->eq
[k
][1 + nparam
+ d
+ i
], -1);
245 for (j
= 0; j
< n
; ++j
)
246 isl_int_set_si(path
->eq
[k
][1 + nparam
+ 2 * d
+ j
], 1);
248 for (j
= 0; j
< n
; ++j
)
249 isl_int_set(path
->eq
[k
][1 + nparam
+ 2 * d
+ j
],
253 for (i
= 0; i
< n
; ++i
) {
254 k
= isl_basic_map_alloc_inequality(path
);
257 isl_seq_clr(path
->ineq
[k
], 1 + isl_basic_map_total_dim(path
));
258 isl_int_set_si(path
->ineq
[k
][1 + nparam
+ 2 * d
+ i
], 1);
263 path
= isl_basic_map_simplify(path
);
264 path
= isl_basic_map_finalize(path
);
265 return isl_map_from_basic_map(path
);
268 isl_basic_map_free(path
);
277 /* Check whether the parametric constant term of constraint c is never
278 * positive in "bset".
280 static int parametric_constant_never_positive(__isl_keep isl_basic_set
*bset
,
281 isl_int
*c
, int *div_purity
)
290 n_div
= isl_basic_set_dim(bset
, isl_dim_div
);
291 d
= isl_basic_set_dim(bset
, isl_dim_set
);
292 nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
294 bset
= isl_basic_set_copy(bset
);
295 bset
= isl_basic_set_cow(bset
);
296 bset
= isl_basic_set_extend_constraints(bset
, 0, 1);
297 k
= isl_basic_set_alloc_inequality(bset
);
300 isl_seq_clr(bset
->ineq
[k
], 1 + isl_basic_set_total_dim(bset
));
301 isl_seq_cpy(bset
->ineq
[k
], c
, 1 + nparam
);
302 for (i
= 0; i
< n_div
; ++i
) {
303 if (div_purity
[i
] != PURE_PARAM
)
305 isl_int_set(bset
->ineq
[k
][1 + nparam
+ d
+ i
],
306 c
[1 + nparam
+ d
+ i
]);
308 isl_int_sub_ui(bset
->ineq
[k
][0], bset
->ineq
[k
][0], 1);
309 empty
= isl_basic_set_is_empty(bset
);
310 isl_basic_set_free(bset
);
314 isl_basic_set_free(bset
);
318 /* Return PURE_PARAM if only the coefficients of the parameters are non-zero.
319 * Return PURE_VAR if only the coefficients of the set variables are non-zero.
320 * Return MIXED if only the coefficients of the parameters and the set
321 * variables are non-zero and if moreover the parametric constant
322 * can never attain positive values.
323 * Return IMPURE otherwise.
325 static int purity(__isl_keep isl_basic_set
*bset
, isl_int
*c
, int *div_purity
,
335 n_div
= isl_basic_set_dim(bset
, isl_dim_div
);
336 d
= isl_basic_set_dim(bset
, isl_dim_set
);
337 nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
339 for (i
= 0; i
< n_div
; ++i
) {
340 if (isl_int_is_zero(c
[1 + nparam
+ d
+ i
]))
342 switch (div_purity
[i
]) {
343 case PURE_PARAM
: p
= 1; break;
344 case PURE_VAR
: v
= 1; break;
345 default: return IMPURE
;
348 if (!p
&& isl_seq_first_non_zero(c
+ 1, nparam
) == -1)
350 if (!v
&& isl_seq_first_non_zero(c
+ 1 + nparam
, d
) == -1)
353 empty
= parametric_constant_never_positive(bset
, c
, div_purity
);
354 if (eq
&& empty
>= 0 && !empty
) {
355 isl_seq_neg(c
, c
, 1 + nparam
+ d
+ n_div
);
356 empty
= parametric_constant_never_positive(bset
, c
, div_purity
);
359 return empty
< 0 ? -1 : empty
? MIXED
: IMPURE
;
362 /* Return an array of integers indicating the type of each div in bset.
363 * If the div is (recursively) defined in terms of only the parameters,
364 * then the type is PURE_PARAM.
365 * If the div is (recursively) defined in terms of only the set variables,
366 * then the type is PURE_VAR.
367 * Otherwise, the type is IMPURE.
369 static __isl_give
int *get_div_purity(__isl_keep isl_basic_set
*bset
)
380 n_div
= isl_basic_set_dim(bset
, isl_dim_div
);
381 d
= isl_basic_set_dim(bset
, isl_dim_set
);
382 nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
384 div_purity
= isl_alloc_array(bset
->ctx
, int, n_div
);
388 for (i
= 0; i
< bset
->n_div
; ++i
) {
390 if (isl_int_is_zero(bset
->div
[i
][0])) {
391 div_purity
[i
] = IMPURE
;
394 if (isl_seq_first_non_zero(bset
->div
[i
] + 2, nparam
) != -1)
396 if (isl_seq_first_non_zero(bset
->div
[i
] + 2 + nparam
, d
) != -1)
398 for (j
= 0; j
< i
; ++j
) {
399 if (isl_int_is_zero(bset
->div
[i
][2 + nparam
+ d
+ j
]))
401 switch (div_purity
[j
]) {
402 case PURE_PARAM
: p
= 1; break;
403 case PURE_VAR
: v
= 1; break;
404 default: p
= v
= 1; break;
407 div_purity
[i
] = v
? p
? IMPURE
: PURE_VAR
: PURE_PARAM
;
413 /* Given a path with the as yet unconstrained length at position "pos",
414 * check if setting the length to zero results in only the identity
417 int empty_path_is_identity(__isl_keep isl_basic_map
*path
, unsigned pos
)
419 isl_basic_map
*test
= NULL
;
420 isl_basic_map
*id
= NULL
;
424 test
= isl_basic_map_copy(path
);
425 test
= isl_basic_map_extend_constraints(test
, 1, 0);
426 k
= isl_basic_map_alloc_equality(test
);
429 isl_seq_clr(test
->eq
[k
], 1 + isl_basic_map_total_dim(test
));
430 isl_int_set_si(test
->eq
[k
][pos
], 1);
431 id
= isl_basic_map_identity(isl_dim_domain(isl_basic_map_get_dim(path
)));
432 is_id
= isl_basic_map_is_equal(test
, id
);
433 isl_basic_map_free(test
);
434 isl_basic_map_free(id
);
437 isl_basic_map_free(test
);
441 __isl_give isl_basic_map
*add_delta_constraints(__isl_take isl_basic_map
*path
,
442 __isl_keep isl_basic_set
*delta
, unsigned off
, unsigned nparam
,
443 unsigned d
, int *div_purity
, int eq
)
446 int n
= eq
? delta
->n_eq
: delta
->n_ineq
;
447 isl_int
**delta_c
= eq
? delta
->eq
: delta
->ineq
;
450 n_div
= isl_basic_set_dim(delta
, isl_dim_div
);
452 for (i
= 0; i
< n
; ++i
) {
454 int p
= purity(delta
, delta_c
[i
], div_purity
, eq
);
459 if (eq
&& p
!= MIXED
) {
460 k
= isl_basic_map_alloc_equality(path
);
461 path_c
= path
->eq
[k
];
463 k
= isl_basic_map_alloc_inequality(path
);
464 path_c
= path
->ineq
[k
];
468 isl_seq_clr(path_c
, 1 + isl_basic_map_total_dim(path
));
470 isl_seq_cpy(path_c
+ off
,
471 delta_c
[i
] + 1 + nparam
, d
);
472 isl_int_set(path_c
[off
+ d
], delta_c
[i
][0]);
473 } else if (p
== PURE_PARAM
) {
474 isl_seq_cpy(path_c
, delta_c
[i
], 1 + nparam
);
476 isl_seq_cpy(path_c
+ off
,
477 delta_c
[i
] + 1 + nparam
, d
);
478 isl_seq_cpy(path_c
, delta_c
[i
], 1 + nparam
);
480 isl_seq_cpy(path_c
+ off
- n_div
,
481 delta_c
[i
] + 1 + nparam
+ d
, n_div
);
486 isl_basic_map_free(path
);
490 /* Given a set of offsets "delta", construct a relation of the
491 * given dimension specification (Z^{n+1} -> Z^{n+1}) that
492 * is an overapproximation of the relations that
493 * maps an element x to any element that can be reached
494 * by taking a non-negative number of steps along any of
495 * the elements in "delta".
496 * That is, construct an approximation of
498 * { [x] -> [y] : exists f \in \delta, k \in Z :
499 * y = x + k [f, 1] and k >= 0 }
501 * For any element in this relation, the number of steps taken
502 * is equal to the difference in the final coordinates.
504 * In particular, let delta be defined as
506 * \delta = [p] -> { [x] : A x + a >= and B p + b >= 0 and
507 * C x + C'p + c >= 0 and
508 * D x + D'p + d >= 0 }
510 * where the constraints C x + C'p + c >= 0 are such that the parametric
511 * constant term of each constraint j, "C_j x + C'_j p + c_j",
512 * can never attain positive values, then the relation is constructed as
514 * { [x] -> [y] : exists [f, k] \in Z^{n+1} : y = x + f and
515 * A f + k a >= 0 and B p + b >= 0 and
516 * C f + C'p + c >= 0 and k >= 1 }
517 * union { [x] -> [x] }
519 * If the zero-length paths happen to correspond exactly to the identity
520 * mapping, then we return
522 * { [x] -> [y] : exists [f, k] \in Z^{n+1} : y = x + f and
523 * A f + k a >= 0 and B p + b >= 0 and
524 * C f + C'p + c >= 0 and k >= 0 }
528 * Existentially quantified variables in \delta are handled by
529 * classifying them as independent of the parameters, purely
530 * parameter dependent and others. Constraints containing
531 * any of the other existentially quantified variables are removed.
532 * This is safe, but leads to an additional overapproximation.
534 static __isl_give isl_map
*path_along_delta(__isl_take isl_dim
*dim
,
535 __isl_take isl_basic_set
*delta
)
537 isl_basic_map
*path
= NULL
;
544 int *div_purity
= NULL
;
548 n_div
= isl_basic_set_dim(delta
, isl_dim_div
);
549 d
= isl_basic_set_dim(delta
, isl_dim_set
);
550 nparam
= isl_basic_set_dim(delta
, isl_dim_param
);
551 path
= isl_basic_map_alloc_dim(isl_dim_copy(dim
), n_div
+ d
+ 1,
552 d
+ 1 + delta
->n_eq
, delta
->n_eq
+ delta
->n_ineq
+ 1);
553 off
= 1 + nparam
+ 2 * (d
+ 1) + n_div
;
555 for (i
= 0; i
< n_div
+ d
+ 1; ++i
) {
556 k
= isl_basic_map_alloc_div(path
);
559 isl_int_set_si(path
->div
[k
][0], 0);
562 for (i
= 0; i
< d
+ 1; ++i
) {
563 k
= isl_basic_map_alloc_equality(path
);
566 isl_seq_clr(path
->eq
[k
], 1 + isl_basic_map_total_dim(path
));
567 isl_int_set_si(path
->eq
[k
][1 + nparam
+ i
], 1);
568 isl_int_set_si(path
->eq
[k
][1 + nparam
+ d
+ 1 + i
], -1);
569 isl_int_set_si(path
->eq
[k
][off
+ i
], 1);
572 div_purity
= get_div_purity(delta
);
576 path
= add_delta_constraints(path
, delta
, off
, nparam
, d
, div_purity
, 1);
577 path
= add_delta_constraints(path
, delta
, off
, nparam
, d
, div_purity
, 0);
579 is_id
= empty_path_is_identity(path
, off
+ d
);
583 k
= isl_basic_map_alloc_inequality(path
);
586 isl_seq_clr(path
->ineq
[k
], 1 + isl_basic_map_total_dim(path
));
588 isl_int_set_si(path
->ineq
[k
][0], -1);
589 isl_int_set_si(path
->ineq
[k
][off
+ d
], 1);
592 isl_basic_set_free(delta
);
593 path
= isl_basic_map_finalize(path
);
596 return isl_map_from_basic_map(path
);
598 return isl_basic_map_union(path
,
599 isl_basic_map_identity(isl_dim_domain(dim
)));
603 isl_basic_set_free(delta
);
604 isl_basic_map_free(path
);
608 /* Given a dimension specification Z^{n+1} -> Z^{n+1} and a parameter "param",
609 * construct a map that equates the parameter to the difference
610 * in the final coordinates and imposes that this difference is positive.
613 * { [x,x_s] -> [y,y_s] : k = y_s - x_s > 0 }
615 static __isl_give isl_map
*equate_parameter_to_length(__isl_take isl_dim
*dim
,
618 struct isl_basic_map
*bmap
;
623 d
= isl_dim_size(dim
, isl_dim_in
);
624 nparam
= isl_dim_size(dim
, isl_dim_param
);
625 bmap
= isl_basic_map_alloc_dim(dim
, 0, 1, 1);
626 k
= isl_basic_map_alloc_equality(bmap
);
629 isl_seq_clr(bmap
->eq
[k
], 1 + isl_basic_map_total_dim(bmap
));
630 isl_int_set_si(bmap
->eq
[k
][1 + param
], -1);
631 isl_int_set_si(bmap
->eq
[k
][1 + nparam
+ d
- 1], -1);
632 isl_int_set_si(bmap
->eq
[k
][1 + nparam
+ d
+ d
- 1], 1);
634 k
= isl_basic_map_alloc_inequality(bmap
);
637 isl_seq_clr(bmap
->ineq
[k
], 1 + isl_basic_map_total_dim(bmap
));
638 isl_int_set_si(bmap
->ineq
[k
][1 + param
], 1);
639 isl_int_set_si(bmap
->ineq
[k
][0], -1);
641 bmap
= isl_basic_map_finalize(bmap
);
642 return isl_map_from_basic_map(bmap
);
644 isl_basic_map_free(bmap
);
648 /* Check whether "path" is acyclic, where the last coordinates of domain
649 * and range of path encode the number of steps taken.
650 * That is, check whether
652 * { d | d = y - x and (x,y) in path }
654 * does not contain any element with positive last coordinate (positive length)
655 * and zero remaining coordinates (cycle).
657 static int is_acyclic(__isl_take isl_map
*path
)
662 struct isl_set
*delta
;
664 delta
= isl_map_deltas(path
);
665 dim
= isl_set_dim(delta
, isl_dim_set
);
666 for (i
= 0; i
< dim
; ++i
) {
668 delta
= isl_set_lower_bound_si(delta
, isl_dim_set
, i
, 1);
670 delta
= isl_set_fix_si(delta
, isl_dim_set
, i
, 0);
673 acyclic
= isl_set_is_empty(delta
);
679 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
680 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
681 * construct a map that is an overapproximation of the map
682 * that takes an element from the space D \times Z to another
683 * element from the same space, such that the first n coordinates of the
684 * difference between them is a sum of differences between images
685 * and pre-images in one of the R_i and such that the last coordinate
686 * is equal to the number of steps taken.
689 * \Delta_i = { y - x | (x, y) in R_i }
691 * then the constructed map is an overapproximation of
693 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
694 * d = (\sum_i k_i \delta_i, \sum_i k_i) }
696 * The elements of the singleton \Delta_i's are collected as the
697 * rows of the steps matrix. For all these \Delta_i's together,
698 * a single path is constructed.
699 * For each of the other \Delta_i's, we compute an overapproximation
700 * of the paths along elements of \Delta_i.
701 * Since each of these paths performs an addition, composition is
702 * symmetric and we can simply compose all resulting paths in any order.
704 static __isl_give isl_map
*construct_extended_path(__isl_take isl_dim
*dim
,
705 __isl_keep isl_map
*map
, int *project
)
707 struct isl_mat
*steps
= NULL
;
708 struct isl_map
*path
= NULL
;
712 d
= isl_map_dim(map
, isl_dim_in
);
714 path
= isl_map_identity(isl_dim_domain(isl_dim_copy(dim
)));
716 steps
= isl_mat_alloc(map
->ctx
, map
->n
, d
);
721 for (i
= 0; i
< map
->n
; ++i
) {
722 struct isl_basic_set
*delta
;
724 delta
= isl_basic_map_deltas(isl_basic_map_copy(map
->p
[i
]));
726 for (j
= 0; j
< d
; ++j
) {
729 fixed
= isl_basic_set_fast_dim_is_fixed(delta
, j
,
732 isl_basic_set_free(delta
);
741 path
= isl_map_apply_range(path
,
742 path_along_delta(isl_dim_copy(dim
), delta
));
743 path
= isl_map_coalesce(path
);
745 isl_basic_set_free(delta
);
752 path
= isl_map_apply_range(path
,
753 path_along_steps(isl_dim_copy(dim
), steps
));
756 if (project
&& *project
) {
757 *project
= is_acyclic(isl_map_copy(path
));
772 static int isl_set_overlaps(__isl_keep isl_set
*set1
, __isl_keep isl_set
*set2
)
777 if (!isl_dim_tuple_match(set1
->dim
, isl_dim_set
, set2
->dim
, isl_dim_set
))
780 i
= isl_set_intersect(isl_set_copy(set1
), isl_set_copy(set2
));
781 no_overlap
= isl_set_is_empty(i
);
784 return no_overlap
< 0 ? -1 : !no_overlap
;
787 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
788 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
789 * construct a map that is an overapproximation of the map
790 * that takes an element from the dom R \times Z to an
791 * element from ran R \times Z, such that the first n coordinates of the
792 * difference between them is a sum of differences between images
793 * and pre-images in one of the R_i and such that the last coordinate
794 * is equal to the number of steps taken.
797 * \Delta_i = { y - x | (x, y) in R_i }
799 * then the constructed map is an overapproximation of
801 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
802 * d = (\sum_i k_i \delta_i, \sum_i k_i) and
803 * x in dom R and x + d in ran R and
806 static __isl_give isl_map
*construct_component(__isl_take isl_dim
*dim
,
807 __isl_keep isl_map
*map
, int *exact
, int project
)
809 struct isl_set
*domain
= NULL
;
810 struct isl_set
*range
= NULL
;
811 struct isl_map
*app
= NULL
;
812 struct isl_map
*path
= NULL
;
814 domain
= isl_map_domain(isl_map_copy(map
));
815 domain
= isl_set_coalesce(domain
);
816 range
= isl_map_range(isl_map_copy(map
));
817 range
= isl_set_coalesce(range
);
818 if (!isl_set_overlaps(domain
, range
)) {
819 isl_set_free(domain
);
823 map
= isl_map_copy(map
);
824 map
= isl_map_add(map
, isl_dim_in
, 1);
825 map
= isl_map_add(map
, isl_dim_out
, 1);
826 map
= set_path_length(map
, 1, 1);
829 app
= isl_map_from_domain_and_range(domain
, range
);
830 app
= isl_map_add(app
, isl_dim_in
, 1);
831 app
= isl_map_add(app
, isl_dim_out
, 1);
833 path
= construct_extended_path(isl_dim_copy(dim
), map
,
834 exact
&& *exact
? &project
: NULL
);
835 app
= isl_map_intersect(app
, path
);
837 if (exact
&& *exact
&&
838 (*exact
= check_exactness(isl_map_copy(map
), isl_map_copy(app
),
843 app
= set_path_length(app
, 0, 1);
851 /* Call construct_component and, if "project" is set, project out
852 * the final coordinates.
854 static __isl_give isl_map
*construct_projected_component(
855 __isl_take isl_dim
*dim
,
856 __isl_keep isl_map
*map
, int *exact
, int project
)
863 d
= isl_dim_size(dim
, isl_dim_in
);
865 app
= construct_component(dim
, map
, exact
, project
);
867 app
= isl_map_project_out(app
, isl_dim_in
, d
- 1, 1);
868 app
= isl_map_project_out(app
, isl_dim_out
, d
- 1, 1);
873 /* Compute an extended version, i.e., with path lengths, of
874 * an overapproximation of the transitive closure of "bmap"
875 * with path lengths greater than or equal to zero and with
876 * domain and range equal to "dom".
878 static __isl_give isl_map
*q_closure(__isl_take isl_dim
*dim
,
879 __isl_take isl_set
*dom
, __isl_keep isl_basic_map
*bmap
, int *exact
)
886 dom
= isl_set_add(dom
, isl_dim_set
, 1);
887 app
= isl_map_from_domain_and_range(dom
, isl_set_copy(dom
));
888 map
= isl_map_from_basic_map(isl_basic_map_copy(bmap
));
889 path
= construct_extended_path(dim
, map
, &project
);
890 app
= isl_map_intersect(app
, path
);
892 if ((*exact
= check_exactness(map
, isl_map_copy(app
), project
)) < 0)
901 /* Check whether qc has any elements of length at least one
902 * with domain and/or range outside of dom and ran.
904 static int has_spurious_elements(__isl_keep isl_map
*qc
,
905 __isl_keep isl_set
*dom
, __isl_keep isl_set
*ran
)
911 if (!qc
|| !dom
|| !ran
)
914 d
= isl_map_dim(qc
, isl_dim_in
);
916 qc
= isl_map_copy(qc
);
917 qc
= set_path_length(qc
, 0, 1);
918 qc
= isl_map_project_out(qc
, isl_dim_in
, d
- 1, 1);
919 qc
= isl_map_project_out(qc
, isl_dim_out
, d
- 1, 1);
921 s
= isl_map_domain(isl_map_copy(qc
));
922 subset
= isl_set_is_subset(s
, dom
);
931 s
= isl_map_range(qc
);
932 subset
= isl_set_is_subset(s
, ran
);
935 return subset
< 0 ? -1 : !subset
;
944 /* For each basic map in "map", except i, check whether it combines
945 * with the transitive closure that is reflexive on C combines
946 * to the left and to the right.
950 * dom map_j \subseteq C
952 * then right[j] is set to 1. Otherwise, if
954 * ran map_i \cap dom map_j = \emptyset
956 * then right[j] is set to 0. Otherwise, composing to the right
959 * Similar, for composing to the left, we have if
961 * ran map_j \subseteq C
963 * then left[j] is set to 1. Otherwise, if
965 * dom map_i \cap ran map_j = \emptyset
967 * then left[j] is set to 0. Otherwise, composing to the left
970 * The return value is or'd with LEFT if composing to the left
971 * is possible and with RIGHT if composing to the right is possible.
973 static int composability(__isl_keep isl_set
*C
, int i
,
974 isl_set
**dom
, isl_set
**ran
, int *left
, int *right
,
975 __isl_keep isl_map
*map
)
981 for (j
= 0; j
< map
->n
&& ok
; ++j
) {
982 int overlaps
, subset
;
988 dom
[j
] = isl_set_from_basic_set(
989 isl_basic_map_domain(
990 isl_basic_map_copy(map
->p
[j
])));
993 overlaps
= isl_set_overlaps(ran
[i
], dom
[j
]);
999 subset
= isl_set_is_subset(dom
[j
], C
);
1011 ran
[j
] = isl_set_from_basic_set(
1012 isl_basic_map_range(
1013 isl_basic_map_copy(map
->p
[j
])));
1016 overlaps
= isl_set_overlaps(dom
[i
], ran
[j
]);
1022 subset
= isl_set_is_subset(ran
[j
], C
);
1036 /* Return a map that is a union of the basic maps in "map", except i,
1037 * composed to left and right with qc based on the entries of "left"
1040 static __isl_give isl_map
*compose(__isl_keep isl_map
*map
, int i
,
1041 __isl_take isl_map
*qc
, int *left
, int *right
)
1046 comp
= isl_map_empty(isl_map_get_dim(map
));
1047 for (j
= 0; j
< map
->n
; ++j
) {
1053 map_j
= isl_map_from_basic_map(isl_basic_map_copy(map
->p
[j
]));
1054 if (left
&& left
[j
])
1055 map_j
= isl_map_apply_range(map_j
, isl_map_copy(qc
));
1056 if (right
&& right
[j
])
1057 map_j
= isl_map_apply_range(isl_map_copy(qc
), map_j
);
1058 comp
= isl_map_union(comp
, map_j
);
1061 comp
= isl_map_compute_divs(comp
);
1062 comp
= isl_map_coalesce(comp
);
1069 /* Compute the transitive closure of "map" incrementally by
1076 * map_i^+ \cup ((id \cup map_i^) \circ qc^+)
1080 * map_i^+ \cup (qc^+ \circ (id \cup map_i^))
1082 * depending on whether left or right are NULL.
1084 static __isl_give isl_map
*compute_incremental(
1085 __isl_take isl_dim
*dim
, __isl_keep isl_map
*map
,
1086 int i
, __isl_take isl_map
*qc
, int *left
, int *right
, int *exact
)
1090 isl_map
*rtc
= NULL
;
1094 isl_assert(map
->ctx
, left
|| right
, goto error
);
1096 map_i
= isl_map_from_basic_map(isl_basic_map_copy(map
->p
[i
]));
1097 tc
= construct_projected_component(isl_dim_copy(dim
), map_i
,
1099 isl_map_free(map_i
);
1102 qc
= isl_map_transitive_closure(qc
, exact
);
1108 return isl_map_universe(isl_map_get_dim(map
));
1111 if (!left
|| !right
)
1112 rtc
= isl_map_union(isl_map_copy(tc
),
1113 isl_map_identity(isl_dim_domain(isl_map_get_dim(tc
))));
1115 qc
= isl_map_apply_range(rtc
, qc
);
1117 qc
= isl_map_apply_range(qc
, rtc
);
1118 qc
= isl_map_union(tc
, qc
);
1129 /* Given a map "map", try to find a basic map such that
1130 * map^+ can be computed as
1132 * map^+ = map_i^+ \cup
1133 * \bigcup_j ((map_i^+ \cup Id_C)^+ \circ map_j \circ (map_i^+ \cup Id_C))^+
1135 * with C the simple hull of the domain and range of the input map.
1136 * map_i^ \cup Id_C is computed by allowing the path lengths to be zero
1137 * and by intersecting domain and range with C.
1138 * Of course, we need to check that this is actually equal to map_i^ \cup Id_C.
1139 * Also, we only use the incremental computation if all the transitive
1140 * closures are exact and if the number of basic maps in the union,
1141 * after computing the integer divisions, is smaller than the number
1142 * of basic maps in the input map.
1144 static int incemental_on_entire_domain(__isl_keep isl_dim
*dim
,
1145 __isl_keep isl_map
*map
,
1146 isl_set
**dom
, isl_set
**ran
, int *left
, int *right
,
1147 __isl_give isl_map
**res
)
1155 C
= isl_set_union(isl_map_domain(isl_map_copy(map
)),
1156 isl_map_range(isl_map_copy(map
)));
1157 C
= isl_set_from_basic_set(isl_set_simple_hull(C
));
1165 d
= isl_map_dim(map
, isl_dim_in
);
1167 for (i
= 0; i
< map
->n
; ++i
) {
1169 int exact_i
, spurious
;
1171 dom
[i
] = isl_set_from_basic_set(isl_basic_map_domain(
1172 isl_basic_map_copy(map
->p
[i
])));
1173 ran
[i
] = isl_set_from_basic_set(isl_basic_map_range(
1174 isl_basic_map_copy(map
->p
[i
])));
1175 qc
= q_closure(isl_dim_copy(dim
), isl_set_copy(C
),
1176 map
->p
[i
], &exact_i
);
1183 spurious
= has_spurious_elements(qc
, dom
[i
], ran
[i
]);
1190 qc
= isl_map_project_out(qc
, isl_dim_in
, d
, 1);
1191 qc
= isl_map_project_out(qc
, isl_dim_out
, d
, 1);
1192 qc
= isl_map_compute_divs(qc
);
1193 for (j
= 0; j
< map
->n
; ++j
)
1194 left
[j
] = right
[j
] = 1;
1195 qc
= compose(map
, i
, qc
, left
, right
);
1198 if (qc
->n
>= map
->n
) {
1202 *res
= compute_incremental(isl_dim_copy(dim
), map
, i
, qc
,
1203 left
, right
, &exact_i
);
1214 return *res
!= NULL
;
1220 /* Try and compute the transitive closure of "map" as
1222 * map^+ = map_i^+ \cup
1223 * \bigcup_j ((map_i^+ \cup Id_C)^+ \circ map_j \circ (map_i^+ \cup Id_C))^+
1225 * with C either the simple hull of the domain and range of the entire
1226 * map or the simple hull of domain and range of map_i.
1228 static __isl_give isl_map
*incremental_closure(__isl_take isl_dim
*dim
,
1229 __isl_keep isl_map
*map
, int *exact
, int project
)
1232 isl_set
**dom
= NULL
;
1233 isl_set
**ran
= NULL
;
1238 isl_map
*res
= NULL
;
1241 return construct_projected_component(dim
, map
, exact
, project
);
1246 return construct_projected_component(dim
, map
, exact
, project
);
1248 d
= isl_map_dim(map
, isl_dim_in
);
1250 dom
= isl_calloc_array(map
->ctx
, isl_set
*, map
->n
);
1251 ran
= isl_calloc_array(map
->ctx
, isl_set
*, map
->n
);
1252 left
= isl_calloc_array(map
->ctx
, int, map
->n
);
1253 right
= isl_calloc_array(map
->ctx
, int, map
->n
);
1254 if (!ran
|| !dom
|| !left
|| !right
)
1257 if (incemental_on_entire_domain(dim
, map
, dom
, ran
, left
, right
, &res
) < 0)
1260 for (i
= 0; !res
&& i
< map
->n
; ++i
) {
1262 int exact_i
, spurious
, comp
;
1264 dom
[i
] = isl_set_from_basic_set(
1265 isl_basic_map_domain(
1266 isl_basic_map_copy(map
->p
[i
])));
1270 ran
[i
] = isl_set_from_basic_set(
1271 isl_basic_map_range(
1272 isl_basic_map_copy(map
->p
[i
])));
1275 C
= isl_set_union(isl_set_copy(dom
[i
]),
1276 isl_set_copy(ran
[i
]));
1277 C
= isl_set_from_basic_set(isl_set_simple_hull(C
));
1284 comp
= composability(C
, i
, dom
, ran
, left
, right
, map
);
1285 if (!comp
|| comp
< 0) {
1291 qc
= q_closure(isl_dim_copy(dim
), C
, map
->p
[i
], &exact_i
);
1298 spurious
= has_spurious_elements(qc
, dom
[i
], ran
[i
]);
1305 qc
= isl_map_project_out(qc
, isl_dim_in
, d
, 1);
1306 qc
= isl_map_project_out(qc
, isl_dim_out
, d
, 1);
1307 qc
= isl_map_compute_divs(qc
);
1308 qc
= compose(map
, i
, qc
, (comp
& LEFT
) ? left
: NULL
,
1309 (comp
& RIGHT
) ? right
: NULL
);
1312 if (qc
->n
>= map
->n
) {
1316 res
= compute_incremental(isl_dim_copy(dim
), map
, i
, qc
,
1317 (comp
& LEFT
) ? left
: NULL
,
1318 (comp
& RIGHT
) ? right
: NULL
, &exact_i
);
1327 for (i
= 0; i
< map
->n
; ++i
) {
1328 isl_set_free(dom
[i
]);
1329 isl_set_free(ran
[i
]);
1341 return construct_projected_component(dim
, map
, exact
, project
);
1344 for (i
= 0; i
< map
->n
; ++i
)
1345 isl_set_free(dom
[i
]);
1348 for (i
= 0; i
< map
->n
; ++i
)
1349 isl_set_free(ran
[i
]);
1357 /* Given an array of sets "set", add "dom" at position "pos"
1358 * and search for elements at earlier positions that overlap with "dom".
1359 * If any can be found, then merge all of them, together with "dom", into
1360 * a single set and assign the union to the first in the array,
1361 * which becomes the new group leader for all groups involved in the merge.
1362 * During the search, we only consider group leaders, i.e., those with
1363 * group[i] = i, as the other sets have already been combined
1364 * with one of the group leaders.
1366 static int merge(isl_set
**set
, int *group
, __isl_take isl_set
*dom
, int pos
)
1371 set
[pos
] = isl_set_copy(dom
);
1373 for (i
= pos
- 1; i
>= 0; --i
) {
1379 o
= isl_set_overlaps(set
[i
], dom
);
1385 set
[i
] = isl_set_union(set
[i
], set
[group
[pos
]]);
1386 set
[group
[pos
]] = NULL
;
1389 group
[group
[pos
]] = i
;
1400 /* Replace each entry in the n by n grid of maps by the cross product
1401 * with the relation { [i] -> [i + 1] }.
1403 static int add_length(__isl_keep isl_map
*map
, isl_map
***grid
, int n
)
1407 isl_basic_map
*bstep
;
1414 dim
= isl_map_get_dim(map
);
1415 nparam
= isl_dim_size(dim
, isl_dim_param
);
1416 dim
= isl_dim_drop(dim
, isl_dim_in
, 0, isl_dim_size(dim
, isl_dim_in
));
1417 dim
= isl_dim_drop(dim
, isl_dim_out
, 0, isl_dim_size(dim
, isl_dim_out
));
1418 dim
= isl_dim_add(dim
, isl_dim_in
, 1);
1419 dim
= isl_dim_add(dim
, isl_dim_out
, 1);
1420 bstep
= isl_basic_map_alloc_dim(dim
, 0, 1, 0);
1421 k
= isl_basic_map_alloc_equality(bstep
);
1423 isl_basic_map_free(bstep
);
1426 isl_seq_clr(bstep
->eq
[k
], 1 + isl_basic_map_total_dim(bstep
));
1427 isl_int_set_si(bstep
->eq
[k
][0], 1);
1428 isl_int_set_si(bstep
->eq
[k
][1 + nparam
], 1);
1429 isl_int_set_si(bstep
->eq
[k
][1 + nparam
+ 1], -1);
1430 bstep
= isl_basic_map_finalize(bstep
);
1431 step
= isl_map_from_basic_map(bstep
);
1433 for (i
= 0; i
< n
; ++i
)
1434 for (j
= 0; j
< n
; ++j
)
1435 grid
[i
][j
] = isl_map_product(grid
[i
][j
],
1436 isl_map_copy(step
));
1443 /* The core of the Floyd-Warshall algorithm.
1444 * Updates the given n x x matrix of relations in place.
1446 * The algorithm iterates over all vertices. In each step, the whole
1447 * matrix is updated to include all paths that go to the current vertex,
1448 * possibly stay there a while (including passing through earlier vertices)
1449 * and then come back. At the start of each iteration, the diagonal
1450 * element corresponding to the current vertex is replaced by its
1451 * transitive closure to account for all indirect paths that stay
1452 * in the current vertex.
1454 static void floyd_warshall_iterate(isl_map
***grid
, int n
, int *exact
)
1458 for (r
= 0; r
< n
; ++r
) {
1460 grid
[r
][r
] = isl_map_transitive_closure(grid
[r
][r
],
1461 (exact
&& *exact
) ? &r_exact
: NULL
);
1462 if (exact
&& *exact
&& !r_exact
)
1465 for (p
= 0; p
< n
; ++p
)
1466 for (q
= 0; q
< n
; ++q
) {
1468 if (p
== r
&& q
== r
)
1470 loop
= isl_map_apply_range(
1471 isl_map_copy(grid
[p
][r
]),
1472 isl_map_copy(grid
[r
][q
]));
1473 grid
[p
][q
] = isl_map_union(grid
[p
][q
], loop
);
1474 loop
= isl_map_apply_range(
1475 isl_map_copy(grid
[p
][r
]),
1476 isl_map_apply_range(
1477 isl_map_copy(grid
[r
][r
]),
1478 isl_map_copy(grid
[r
][q
])));
1479 grid
[p
][q
] = isl_map_union(grid
[p
][q
], loop
);
1480 grid
[p
][q
] = isl_map_coalesce(grid
[p
][q
]);
1485 /* Given a partition of the domains and ranges of the basic maps in "map",
1486 * apply the Floyd-Warshall algorithm with the elements in the partition
1489 * In particular, there are "n" elements in the partition and "group" is
1490 * an array of length 2 * map->n with entries in [0,n-1].
1492 * We first construct a matrix of relations based on the partition information,
1493 * apply Floyd-Warshall on this matrix of relations and then take the
1494 * union of all entries in the matrix as the final result.
1496 * If we are actually computing the power instead of the transitive closure,
1497 * i.e., when "project" is not set, then the result should have the
1498 * path lengths encoded as the difference between an extra pair of
1499 * coordinates. We therefore apply the nested transitive closures
1500 * to relations that include these lengths. In particular, we replace
1501 * the input relation by the cross product with the unit length relation
1502 * { [i] -> [i + 1] }.
1504 static __isl_give isl_map
*floyd_warshall_with_groups(__isl_take isl_dim
*dim
,
1505 __isl_keep isl_map
*map
, int *exact
, int project
, int *group
, int n
)
1508 isl_map
***grid
= NULL
;
1516 return incremental_closure(dim
, map
, exact
, project
);
1519 grid
= isl_calloc_array(map
->ctx
, isl_map
**, n
);
1522 for (i
= 0; i
< n
; ++i
) {
1523 grid
[i
] = isl_calloc_array(map
->ctx
, isl_map
*, n
);
1526 for (j
= 0; j
< n
; ++j
)
1527 grid
[i
][j
] = isl_map_empty(isl_map_get_dim(map
));
1530 for (k
= 0; k
< map
->n
; ++k
) {
1532 j
= group
[2 * k
+ 1];
1533 grid
[i
][j
] = isl_map_union(grid
[i
][j
],
1534 isl_map_from_basic_map(
1535 isl_basic_map_copy(map
->p
[k
])));
1538 if (!project
&& add_length(map
, grid
, n
) < 0)
1541 floyd_warshall_iterate(grid
, n
, exact
);
1543 app
= isl_map_empty(isl_map_get_dim(map
));
1545 for (i
= 0; i
< n
; ++i
) {
1546 for (j
= 0; j
< n
; ++j
)
1547 app
= isl_map_union(app
, grid
[i
][j
]);
1558 for (i
= 0; i
< n
; ++i
) {
1561 for (j
= 0; j
< n
; ++j
)
1562 isl_map_free(grid
[i
][j
]);
1571 /* Partition the domains and ranges of the n basic relations in list
1572 * into disjoint cells.
1574 * To find the partition, we simply consider all of the domains
1575 * and ranges in turn and combine those that overlap.
1576 * "set" contains the partition elements and "group" indicates
1577 * to which partition element a given domain or range belongs.
1578 * The domain of basic map i corresponds to element 2 * i in these arrays,
1579 * while the domain corresponds to element 2 * i + 1.
1580 * During the construction group[k] is either equal to k,
1581 * in which case set[k] contains the union of all the domains and
1582 * ranges in the corresponding group, or is equal to some l < k,
1583 * with l another domain or range in the same group.
1585 static int *setup_groups(isl_ctx
*ctx
, __isl_keep isl_basic_map
**list
, int n
,
1586 isl_set
***set
, int *n_group
)
1592 *set
= isl_calloc_array(ctx
, isl_set
*, 2 * n
);
1593 group
= isl_alloc_array(ctx
, int, 2 * n
);
1595 if (!*set
|| !group
)
1598 for (i
= 0; i
< n
; ++i
) {
1600 dom
= isl_set_from_basic_set(isl_basic_map_domain(
1601 isl_basic_map_copy(list
[i
])));
1602 if (merge(*set
, group
, dom
, 2 * i
) < 0)
1604 dom
= isl_set_from_basic_set(isl_basic_map_range(
1605 isl_basic_map_copy(list
[i
])));
1606 if (merge(*set
, group
, dom
, 2 * i
+ 1) < 0)
1611 for (i
= 0; i
< 2 * n
; ++i
)
1615 group
[i
] = group
[group
[i
]];
1622 for (i
= 0; i
< 2 * n
; ++i
)
1623 isl_set_free((*set
)[i
]);
1631 /* Check if the domains and ranges of the basic maps in "map" can
1632 * be partitioned, and if so, apply Floyd-Warshall on the elements
1633 * of the partition. Note that we also apply this algorithm
1634 * if we want to compute the power, i.e., when "project" is not set.
1635 * However, the results are unlikely to be exact since the recursive
1636 * calls inside the Floyd-Warshall algorithm typically result in
1637 * non-linear path lengths quite quickly.
1639 static __isl_give isl_map
*floyd_warshall(__isl_take isl_dim
*dim
,
1640 __isl_keep isl_map
*map
, int *exact
, int project
)
1643 isl_set
**set
= NULL
;
1650 return incremental_closure(dim
, map
, exact
, project
);
1652 group
= setup_groups(map
->ctx
, map
->p
, map
->n
, &set
, &n
);
1656 for (i
= 0; i
< 2 * map
->n
; ++i
)
1657 isl_set_free(set
[i
]);
1661 return floyd_warshall_with_groups(dim
, map
, exact
, project
, group
, n
);
1667 /* Structure for representing the nodes in the graph being traversed
1668 * using Tarjan's algorithm.
1669 * index represents the order in which nodes are visited.
1670 * min_index is the index of the root of a (sub)component.
1671 * on_stack indicates whether the node is currently on the stack.
1673 struct basic_map_sort_node
{
1678 /* Structure for representing the graph being traversed
1679 * using Tarjan's algorithm.
1680 * len is the number of nodes
1681 * node is an array of nodes
1682 * stack contains the nodes on the path from the root to the current node
1683 * sp is the stack pointer
1684 * index is the index of the last node visited
1685 * order contains the elements of the components separated by -1
1686 * op represents the current position in order
1688 * check_closed is set if we may have used the fact that
1689 * a pair of basic maps can be interchanged
1691 struct basic_map_sort
{
1693 struct basic_map_sort_node
*node
;
1702 static void basic_map_sort_free(struct basic_map_sort
*s
)
1712 static struct basic_map_sort
*basic_map_sort_alloc(struct isl_ctx
*ctx
, int len
)
1714 struct basic_map_sort
*s
;
1717 s
= isl_calloc_type(ctx
, struct basic_map_sort
);
1721 s
->node
= isl_alloc_array(ctx
, struct basic_map_sort_node
, len
);
1724 for (i
= 0; i
< len
; ++i
)
1725 s
->node
[i
].index
= -1;
1726 s
->stack
= isl_alloc_array(ctx
, int, len
);
1729 s
->order
= isl_alloc_array(ctx
, int, 2 * len
);
1737 s
->check_closed
= 0;
1741 basic_map_sort_free(s
);
1745 /* Check whether in the computation of the transitive closure
1746 * "bmap1" (R_1) should follow (or be part of the same component as)
1749 * That is check whether
1757 * If so, then there is no reason for R_1 to immediately follow R_2
1760 * *check_closed is set if the subset relation holds while
1761 * R_1 \circ R_2 is not empty.
1763 static int basic_map_follows(__isl_keep isl_basic_map
*bmap1
,
1764 __isl_keep isl_basic_map
*bmap2
, int *check_closed
)
1766 struct isl_map
*map12
= NULL
;
1767 struct isl_map
*map21
= NULL
;
1770 if (!isl_dim_tuple_match(bmap1
->dim
, isl_dim_in
, bmap2
->dim
, isl_dim_out
))
1773 map21
= isl_map_from_basic_map(
1774 isl_basic_map_apply_range(
1775 isl_basic_map_copy(bmap2
),
1776 isl_basic_map_copy(bmap1
)));
1777 subset
= isl_map_is_empty(map21
);
1781 isl_map_free(map21
);
1785 if (!isl_dim_tuple_match(bmap1
->dim
, isl_dim_in
, bmap1
->dim
, isl_dim_out
) ||
1786 !isl_dim_tuple_match(bmap2
->dim
, isl_dim_in
, bmap2
->dim
, isl_dim_out
)) {
1787 isl_map_free(map21
);
1791 map12
= isl_map_from_basic_map(
1792 isl_basic_map_apply_range(
1793 isl_basic_map_copy(bmap1
),
1794 isl_basic_map_copy(bmap2
)));
1796 subset
= isl_map_is_subset(map21
, map12
);
1798 isl_map_free(map12
);
1799 isl_map_free(map21
);
1804 return subset
< 0 ? -1 : !subset
;
1806 isl_map_free(map21
);
1810 /* Perform Tarjan's algorithm for computing the strongly connected components
1811 * in the graph with the disjuncts of "map" as vertices and with an
1812 * edge between any pair of disjuncts such that the first has
1813 * to be applied after the second.
1815 static int power_components_tarjan(struct basic_map_sort
*s
,
1816 __isl_keep isl_basic_map
**list
, int i
)
1820 s
->node
[i
].index
= s
->index
;
1821 s
->node
[i
].min_index
= s
->index
;
1822 s
->node
[i
].on_stack
= 1;
1824 s
->stack
[s
->sp
++] = i
;
1826 for (j
= s
->len
- 1; j
>= 0; --j
) {
1831 if (s
->node
[j
].index
>= 0 &&
1832 (!s
->node
[j
].on_stack
||
1833 s
->node
[j
].index
> s
->node
[i
].min_index
))
1836 f
= basic_map_follows(list
[i
], list
[j
], &s
->check_closed
);
1842 if (s
->node
[j
].index
< 0) {
1843 power_components_tarjan(s
, list
, j
);
1844 if (s
->node
[j
].min_index
< s
->node
[i
].min_index
)
1845 s
->node
[i
].min_index
= s
->node
[j
].min_index
;
1846 } else if (s
->node
[j
].index
< s
->node
[i
].min_index
)
1847 s
->node
[i
].min_index
= s
->node
[j
].index
;
1850 if (s
->node
[i
].index
!= s
->node
[i
].min_index
)
1854 j
= s
->stack
[--s
->sp
];
1855 s
->node
[j
].on_stack
= 0;
1856 s
->order
[s
->op
++] = j
;
1858 s
->order
[s
->op
++] = -1;
1863 /* Decompose the "len" basic relations in "list" into strongly connected
1866 static struct basic_map_sort
*basic_map_sort_init(isl_ctx
*ctx
, int len
,
1867 __isl_keep isl_basic_map
**list
)
1870 struct basic_map_sort
*s
= NULL
;
1872 s
= basic_map_sort_alloc(ctx
, len
);
1875 for (i
= len
- 1; i
>= 0; --i
) {
1876 if (s
->node
[i
].index
>= 0)
1878 if (power_components_tarjan(s
, list
, i
) < 0)
1884 basic_map_sort_free(s
);
1888 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
1889 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
1890 * construct a map that is an overapproximation of the map
1891 * that takes an element from the dom R \times Z to an
1892 * element from ran R \times Z, such that the first n coordinates of the
1893 * difference between them is a sum of differences between images
1894 * and pre-images in one of the R_i and such that the last coordinate
1895 * is equal to the number of steps taken.
1896 * If "project" is set, then these final coordinates are not included,
1897 * i.e., a relation of type Z^n -> Z^n is returned.
1900 * \Delta_i = { y - x | (x, y) in R_i }
1902 * then the constructed map is an overapproximation of
1904 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
1905 * d = (\sum_i k_i \delta_i, \sum_i k_i) and
1906 * x in dom R and x + d in ran R }
1910 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
1911 * d = (\sum_i k_i \delta_i) and
1912 * x in dom R and x + d in ran R }
1914 * if "project" is set.
1916 * We first split the map into strongly connected components, perform
1917 * the above on each component and then join the results in the correct
1918 * order, at each join also taking in the union of both arguments
1919 * to allow for paths that do not go through one of the two arguments.
1921 static __isl_give isl_map
*construct_power_components(__isl_take isl_dim
*dim
,
1922 __isl_keep isl_map
*map
, int *exact
, int project
)
1925 struct isl_map
*path
= NULL
;
1926 struct basic_map_sort
*s
= NULL
;
1933 return floyd_warshall(dim
, map
, exact
, project
);
1935 s
= basic_map_sort_init(map
->ctx
, map
->n
, map
->p
);
1940 if (s
->check_closed
&& !exact
)
1941 exact
= &local_exact
;
1947 path
= isl_map_empty(isl_map_get_dim(map
));
1949 path
= isl_map_empty(isl_dim_copy(dim
));
1951 struct isl_map
*comp
;
1952 isl_map
*path_comp
, *path_comb
;
1953 comp
= isl_map_alloc_dim(isl_map_get_dim(map
), n
, 0);
1954 while (s
->order
[i
] != -1) {
1955 comp
= isl_map_add_basic_map(comp
,
1956 isl_basic_map_copy(map
->p
[s
->order
[i
]]));
1960 path_comp
= floyd_warshall(isl_dim_copy(dim
),
1961 comp
, exact
, project
);
1962 path_comb
= isl_map_apply_range(isl_map_copy(path
),
1963 isl_map_copy(path_comp
));
1964 path
= isl_map_union(path
, path_comp
);
1965 path
= isl_map_union(path
, path_comb
);
1971 if (c
> 1 && s
->check_closed
&& !*exact
) {
1974 closed
= isl_map_is_transitively_closed(path
);
1978 basic_map_sort_free(s
);
1980 return floyd_warshall(dim
, map
, orig_exact
, project
);
1984 basic_map_sort_free(s
);
1989 basic_map_sort_free(s
);
1995 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D,
1996 * construct a map that is an overapproximation of the map
1997 * that takes an element from the space D to another
1998 * element from the same space, such that the difference between
1999 * them is a strictly positive sum of differences between images
2000 * and pre-images in one of the R_i.
2001 * The number of differences in the sum is equated to parameter "param".
2004 * \Delta_i = { y - x | (x, y) in R_i }
2006 * then the constructed map is an overapproximation of
2008 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
2009 * d = \sum_i k_i \delta_i and k = \sum_i k_i > 0 }
2012 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
2013 * d = \sum_i k_i \delta_i and \sum_i k_i > 0 }
2015 * if "project" is set.
2017 * If "project" is not set, then
2018 * we construct an extended mapping with an extra coordinate
2019 * that indicates the number of steps taken. In particular,
2020 * the difference in the last coordinate is equal to the number
2021 * of steps taken to move from a domain element to the corresponding
2024 static __isl_give isl_map
*construct_power(__isl_keep isl_map
*map
,
2025 int *exact
, int project
)
2027 struct isl_map
*app
= NULL
;
2028 struct isl_dim
*dim
= NULL
;
2034 dim
= isl_map_get_dim(map
);
2036 d
= isl_dim_size(dim
, isl_dim_in
);
2037 dim
= isl_dim_add(dim
, isl_dim_in
, 1);
2038 dim
= isl_dim_add(dim
, isl_dim_out
, 1);
2040 app
= construct_power_components(isl_dim_copy(dim
), map
,
2048 /* Compute the positive powers of "map", or an overapproximation.
2049 * If the result is exact, then *exact is set to 1.
2051 * If project is set, then we are actually interested in the transitive
2052 * closure, so we can use a more relaxed exactness check.
2053 * The lengths of the paths are also projected out instead of being
2054 * encoded as the difference between an extra pair of final coordinates.
2056 static __isl_give isl_map
*map_power(__isl_take isl_map
*map
,
2057 int *exact
, int project
)
2059 struct isl_map
*app
= NULL
;
2067 isl_assert(map
->ctx
,
2068 isl_map_dim(map
, isl_dim_in
) == isl_map_dim(map
, isl_dim_out
),
2071 app
= construct_power(map
, exact
, project
);
2081 /* Compute the positive powers of "map", or an overapproximation.
2082 * The power is given by parameter "param". If the result is exact,
2083 * then *exact is set to 1.
2084 * map_power constructs an extended relation with the path lengths
2085 * encoded as the difference between the final coordinates.
2086 * In the final step, this difference is equated to the parameter "param"
2087 * and made positive. The extra coordinates are subsequently projected out.
2089 __isl_give isl_map
*isl_map_power(__isl_take isl_map
*map
, unsigned param
,
2092 isl_dim
*target_dim
;
2100 isl_assert(map
->ctx
, param
< isl_map_dim(map
, isl_dim_param
),
2103 d
= isl_map_dim(map
, isl_dim_in
);
2105 map
= isl_map_compute_divs(map
);
2106 map
= isl_map_coalesce(map
);
2108 if (isl_map_fast_is_empty(map
))
2111 target_dim
= isl_map_get_dim(map
);
2112 map
= map_power(map
, exact
, 0);
2114 dim
= isl_map_get_dim(map
);
2115 diff
= equate_parameter_to_length(dim
, param
);
2116 map
= isl_map_intersect(map
, diff
);
2117 map
= isl_map_project_out(map
, isl_dim_in
, d
, 1);
2118 map
= isl_map_project_out(map
, isl_dim_out
, d
, 1);
2120 map
= isl_map_reset_dim(map
, target_dim
);
2128 /* Compute a relation that maps each element in the range of the input
2129 * relation to the lengths of all paths composed of edges in the input
2130 * relation that end up in the given range element.
2131 * The result may be an overapproximation, in which case *exact is set to 0.
2132 * The resulting relation is very similar to the power relation.
2133 * The difference are that the domain has been projected out, the
2134 * range has become the domain and the exponent is the range instead
2137 __isl_give isl_map
*isl_map_reaching_path_lengths(__isl_take isl_map
*map
,
2148 d
= isl_map_dim(map
, isl_dim_in
);
2149 param
= isl_map_dim(map
, isl_dim_param
);
2151 map
= isl_map_compute_divs(map
);
2152 map
= isl_map_coalesce(map
);
2154 if (isl_map_fast_is_empty(map
)) {
2157 map
= isl_map_project_out(map
, isl_dim_out
, 0, d
);
2158 map
= isl_map_add(map
, isl_dim_out
, 1);
2162 map
= map_power(map
, exact
, 0);
2164 map
= isl_map_add(map
, isl_dim_param
, 1);
2165 dim
= isl_map_get_dim(map
);
2166 diff
= equate_parameter_to_length(dim
, param
);
2167 map
= isl_map_intersect(map
, diff
);
2168 map
= isl_map_project_out(map
, isl_dim_in
, 0, d
+ 1);
2169 map
= isl_map_project_out(map
, isl_dim_out
, d
, 1);
2170 map
= isl_map_reverse(map
);
2171 map
= isl_map_move_dims(map
, isl_dim_out
, 0, isl_dim_param
, param
, 1);
2176 /* Check whether equality i of bset is a pure stride constraint
2177 * on a single dimensions, i.e., of the form
2181 * with k a constant and e an existentially quantified variable.
2183 static int is_eq_stride(__isl_keep isl_basic_set
*bset
, int i
)
2195 if (!isl_int_is_zero(bset
->eq
[i
][0]))
2198 nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
2199 d
= isl_basic_set_dim(bset
, isl_dim_set
);
2200 n_div
= isl_basic_set_dim(bset
, isl_dim_div
);
2202 if (isl_seq_first_non_zero(bset
->eq
[i
] + 1, nparam
) != -1)
2204 pos1
= isl_seq_first_non_zero(bset
->eq
[i
] + 1 + nparam
, d
);
2207 if (isl_seq_first_non_zero(bset
->eq
[i
] + 1 + nparam
+ pos1
+ 1,
2208 d
- pos1
- 1) != -1)
2211 pos2
= isl_seq_first_non_zero(bset
->eq
[i
] + 1 + nparam
+ d
, n_div
);
2214 if (isl_seq_first_non_zero(bset
->eq
[i
] + 1 + nparam
+ d
+ pos2
+ 1,
2215 n_div
- pos2
- 1) != -1)
2217 if (!isl_int_is_one(bset
->eq
[i
][1 + nparam
+ pos1
]) &&
2218 !isl_int_is_negone(bset
->eq
[i
][1 + nparam
+ pos1
]))
2224 /* Given a map, compute the smallest superset of this map that is of the form
2226 * { i -> j : L <= j - i <= U and exists a_p: j_p - i_p = M_p a_p }
2228 * (where p ranges over the (non-parametric) dimensions),
2229 * compute the transitive closure of this map, i.e.,
2231 * { i -> j : exists k > 0:
2232 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
2234 * and intersect domain and range of this transitive closure with
2235 * the given domain and range.
2237 * If with_id is set, then try to include as much of the identity mapping
2238 * as possible, by computing
2240 * { i -> j : exists k >= 0:
2241 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
2243 * instead (i.e., allow k = 0).
2245 * In practice, we compute the difference set
2247 * delta = { j - i | i -> j in map },
2249 * look for stride constraint on the individual dimensions and compute
2250 * (constant) lower and upper bounds for each individual dimension,
2251 * adding a constraint for each bound not equal to infinity.
2253 static __isl_give isl_map
*box_closure_on_domain(__isl_take isl_map
*map
,
2254 __isl_take isl_set
*dom
, __isl_take isl_set
*ran
, int with_id
)
2263 isl_map
*app
= NULL
;
2264 isl_basic_set
*aff
= NULL
;
2265 isl_basic_map
*bmap
= NULL
;
2266 isl_vec
*obj
= NULL
;
2271 delta
= isl_map_deltas(isl_map_copy(map
));
2273 aff
= isl_set_affine_hull(isl_set_copy(delta
));
2276 dim
= isl_map_get_dim(map
);
2277 d
= isl_dim_size(dim
, isl_dim_in
);
2278 nparam
= isl_dim_size(dim
, isl_dim_param
);
2279 total
= isl_dim_total(dim
);
2280 bmap
= isl_basic_map_alloc_dim(dim
,
2281 aff
->n_div
+ 1, aff
->n_div
, 2 * d
+ 1);
2282 for (i
= 0; i
< aff
->n_div
+ 1; ++i
) {
2283 k
= isl_basic_map_alloc_div(bmap
);
2286 isl_int_set_si(bmap
->div
[k
][0], 0);
2288 for (i
= 0; i
< aff
->n_eq
; ++i
) {
2289 if (!is_eq_stride(aff
, i
))
2291 k
= isl_basic_map_alloc_equality(bmap
);
2294 isl_seq_clr(bmap
->eq
[k
], 1 + nparam
);
2295 isl_seq_cpy(bmap
->eq
[k
] + 1 + nparam
+ d
,
2296 aff
->eq
[i
] + 1 + nparam
, d
);
2297 isl_seq_neg(bmap
->eq
[k
] + 1 + nparam
,
2298 aff
->eq
[i
] + 1 + nparam
, d
);
2299 isl_seq_cpy(bmap
->eq
[k
] + 1 + nparam
+ 2 * d
,
2300 aff
->eq
[i
] + 1 + nparam
+ d
, aff
->n_div
);
2301 isl_int_set_si(bmap
->eq
[k
][1 + total
+ aff
->n_div
], 0);
2303 obj
= isl_vec_alloc(map
->ctx
, 1 + nparam
+ d
);
2306 isl_seq_clr(obj
->el
, 1 + nparam
+ d
);
2307 for (i
= 0; i
< d
; ++ i
) {
2308 enum isl_lp_result res
;
2310 isl_int_set_si(obj
->el
[1 + nparam
+ i
], 1);
2312 res
= isl_set_solve_lp(delta
, 0, obj
->el
, map
->ctx
->one
, &opt
,
2314 if (res
== isl_lp_error
)
2316 if (res
== isl_lp_ok
) {
2317 k
= isl_basic_map_alloc_inequality(bmap
);
2320 isl_seq_clr(bmap
->ineq
[k
],
2321 1 + nparam
+ 2 * d
+ bmap
->n_div
);
2322 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ i
], -1);
2323 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ d
+ i
], 1);
2324 isl_int_neg(bmap
->ineq
[k
][1 + nparam
+ 2 * d
+ aff
->n_div
], opt
);
2327 res
= isl_set_solve_lp(delta
, 1, obj
->el
, map
->ctx
->one
, &opt
,
2329 if (res
== isl_lp_error
)
2331 if (res
== isl_lp_ok
) {
2332 k
= isl_basic_map_alloc_inequality(bmap
);
2335 isl_seq_clr(bmap
->ineq
[k
],
2336 1 + nparam
+ 2 * d
+ bmap
->n_div
);
2337 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ i
], 1);
2338 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ d
+ i
], -1);
2339 isl_int_set(bmap
->ineq
[k
][1 + nparam
+ 2 * d
+ aff
->n_div
], opt
);
2342 isl_int_set_si(obj
->el
[1 + nparam
+ i
], 0);
2344 k
= isl_basic_map_alloc_inequality(bmap
);
2347 isl_seq_clr(bmap
->ineq
[k
],
2348 1 + nparam
+ 2 * d
+ bmap
->n_div
);
2350 isl_int_set_si(bmap
->ineq
[k
][0], -1);
2351 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ 2 * d
+ aff
->n_div
], 1);
2353 app
= isl_map_from_domain_and_range(dom
, ran
);
2356 isl_basic_set_free(aff
);
2358 bmap
= isl_basic_map_finalize(bmap
);
2359 isl_set_free(delta
);
2362 map
= isl_map_from_basic_map(bmap
);
2363 map
= isl_map_intersect(map
, app
);
2368 isl_basic_map_free(bmap
);
2369 isl_basic_set_free(aff
);
2373 isl_set_free(delta
);
2378 /* Given a map, compute the smallest superset of this map that is of the form
2380 * { i -> j : L <= j - i <= U and exists a_p: j_p - i_p = M_p a_p }
2382 * (where p ranges over the (non-parametric) dimensions),
2383 * compute the transitive closure of this map, i.e.,
2385 * { i -> j : exists k > 0:
2386 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
2388 * and intersect domain and range of this transitive closure with
2389 * domain and range of the original map.
2391 static __isl_give isl_map
*box_closure(__isl_take isl_map
*map
)
2396 domain
= isl_map_domain(isl_map_copy(map
));
2397 domain
= isl_set_coalesce(domain
);
2398 range
= isl_map_range(isl_map_copy(map
));
2399 range
= isl_set_coalesce(range
);
2401 return box_closure_on_domain(map
, domain
, range
, 0);
2404 /* Given a map, compute the smallest superset of this map that is of the form
2406 * { i -> j : L <= j - i <= U and exists a_p: j_p - i_p = M_p a_p }
2408 * (where p ranges over the (non-parametric) dimensions),
2409 * compute the transitive and partially reflexive closure of this map, i.e.,
2411 * { i -> j : exists k >= 0:
2412 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
2414 * and intersect domain and range of this transitive closure with
2417 static __isl_give isl_map
*box_closure_with_identity(__isl_take isl_map
*map
,
2418 __isl_take isl_set
*dom
)
2420 return box_closure_on_domain(map
, dom
, isl_set_copy(dom
), 1);
2423 /* Check whether app is the transitive closure of map.
2424 * In particular, check that app is acyclic and, if so,
2427 * app \subset (map \cup (map \circ app))
2429 static int check_exactness_omega(__isl_keep isl_map
*map
,
2430 __isl_keep isl_map
*app
)
2434 int is_empty
, is_exact
;
2438 delta
= isl_map_deltas(isl_map_copy(app
));
2439 d
= isl_set_dim(delta
, isl_dim_set
);
2440 for (i
= 0; i
< d
; ++i
)
2441 delta
= isl_set_fix_si(delta
, isl_dim_set
, i
, 0);
2442 is_empty
= isl_set_is_empty(delta
);
2443 isl_set_free(delta
);
2449 test
= isl_map_apply_range(isl_map_copy(app
), isl_map_copy(map
));
2450 test
= isl_map_union(test
, isl_map_copy(map
));
2451 is_exact
= isl_map_is_subset(app
, test
);
2457 /* Check if basic map M_i can be combined with all the other
2458 * basic maps such that
2462 * can be computed as
2464 * M_i \cup (\cup_{j \ne i} M_i^* \circ M_j \circ M_i^*)^+
2466 * In particular, check if we can compute a compact representation
2469 * M_i^* \circ M_j \circ M_i^*
2472 * Let M_i^? be an extension of M_i^+ that allows paths
2473 * of length zero, i.e., the result of box_closure(., 1).
2474 * The criterion, as proposed by Kelly et al., is that
2475 * id = M_i^? - M_i^+ can be represented as a basic map
2478 * id \circ M_j \circ id = M_j
2482 * If this function returns 1, then tc and qc are set to
2483 * M_i^+ and M_i^?, respectively.
2485 static int can_be_split_off(__isl_keep isl_map
*map
, int i
,
2486 __isl_give isl_map
**tc
, __isl_give isl_map
**qc
)
2488 isl_map
*map_i
, *id
= NULL
;
2495 C
= isl_set_union(isl_map_domain(isl_map_copy(map
)),
2496 isl_map_range(isl_map_copy(map
)));
2497 C
= isl_set_from_basic_set(isl_set_simple_hull(C
));
2501 map_i
= isl_map_from_basic_map(isl_basic_map_copy(map
->p
[i
]));
2502 *tc
= box_closure(isl_map_copy(map_i
));
2503 *qc
= box_closure_with_identity(map_i
, C
);
2504 id
= isl_map_subtract(isl_map_copy(*qc
), isl_map_copy(*tc
));
2508 if (id
->n
!= 1 || (*qc
)->n
!= 1)
2511 for (j
= 0; j
< map
->n
; ++j
) {
2512 isl_map
*map_j
, *test
;
2517 map_j
= isl_map_from_basic_map(
2518 isl_basic_map_copy(map
->p
[j
]));
2519 test
= isl_map_apply_range(isl_map_copy(id
),
2520 isl_map_copy(map_j
));
2521 test
= isl_map_apply_range(test
, isl_map_copy(id
));
2522 is_ok
= isl_map_is_equal(test
, map_j
);
2523 isl_map_free(map_j
);
2551 static __isl_give isl_map
*box_closure_with_check(__isl_take isl_map
*map
,
2556 app
= box_closure(isl_map_copy(map
));
2558 *exact
= check_exactness_omega(map
, app
);
2564 /* Compute an overapproximation of the transitive closure of "map"
2565 * using a variation of the algorithm from
2566 * "Transitive Closure of Infinite Graphs and its Applications"
2569 * We first check whether we can can split of any basic map M_i and
2576 * M_i \cup (\cup_{j \ne i} M_i^* \circ M_j \circ M_i^*)^+
2578 * using a recursive call on the remaining map.
2580 * If not, we simply call box_closure on the whole map.
2582 static __isl_give isl_map
*transitive_closure_omega(__isl_take isl_map
*map
,
2592 return box_closure_with_check(map
, exact
);
2594 for (i
= 0; i
< map
->n
; ++i
) {
2597 ok
= can_be_split_off(map
, i
, &tc
, &qc
);
2603 app
= isl_map_alloc_dim(isl_map_get_dim(map
), map
->n
- 1, 0);
2605 for (j
= 0; j
< map
->n
; ++j
) {
2608 app
= isl_map_add_basic_map(app
,
2609 isl_basic_map_copy(map
->p
[j
]));
2612 app
= isl_map_apply_range(isl_map_copy(qc
), app
);
2613 app
= isl_map_apply_range(app
, qc
);
2615 app
= isl_map_union(tc
, transitive_closure_omega(app
, NULL
));
2616 exact_i
= check_exactness_omega(map
, app
);
2628 return box_closure_with_check(map
, exact
);
2634 /* Compute the transitive closure of "map", or an overapproximation.
2635 * If the result is exact, then *exact is set to 1.
2636 * Simply use map_power to compute the powers of map, but tell
2637 * it to project out the lengths of the paths instead of equating
2638 * the length to a parameter.
2640 __isl_give isl_map
*isl_map_transitive_closure(__isl_take isl_map
*map
,
2643 isl_dim
*target_dim
;
2649 if (map
->ctx
->opt
->closure
== ISL_CLOSURE_OMEGA
)
2650 return transitive_closure_omega(map
, exact
);
2652 map
= isl_map_compute_divs(map
);
2653 map
= isl_map_coalesce(map
);
2654 closed
= isl_map_is_transitively_closed(map
);
2663 target_dim
= isl_map_get_dim(map
);
2664 map
= map_power(map
, exact
, 1);
2665 map
= isl_map_reset_dim(map
, target_dim
);
2673 static int inc_count(__isl_take isl_map
*map
, void *user
)
2684 static int collect_basic_map(__isl_take isl_map
*map
, void *user
)
2687 isl_basic_map
***next
= user
;
2689 for (i
= 0; i
< map
->n
; ++i
) {
2690 **next
= isl_basic_map_copy(map
->p
[i
]);
2703 /* Perform Floyd-Warshall on the given list of basic relations.
2704 * The basic relations may live in different dimensions,
2705 * but basic relations that get assigned to the diagonal of the
2706 * grid have domains and ranges of the same dimension and so
2707 * the standard algorithm can be used because the nested transitive
2708 * closures are only applied to diagonal elements and because all
2709 * compositions are peformed on relations with compatible domains and ranges.
2711 static __isl_give isl_union_map
*union_floyd_warshall_on_list(isl_ctx
*ctx
,
2712 __isl_keep isl_basic_map
**list
, int n
, int *exact
)
2717 isl_set
**set
= NULL
;
2718 isl_map
***grid
= NULL
;
2721 group
= setup_groups(ctx
, list
, n
, &set
, &n_group
);
2725 grid
= isl_calloc_array(ctx
, isl_map
**, n_group
);
2728 for (i
= 0; i
< n_group
; ++i
) {
2729 grid
[i
] = isl_calloc_array(map
->ctx
, isl_map
*, n_group
);
2732 for (j
= 0; j
< n_group
; ++j
) {
2733 isl_dim
*dim1
, *dim2
, *dim
;
2734 dim1
= isl_dim_reverse(isl_set_get_dim(set
[i
]));
2735 dim2
= isl_set_get_dim(set
[j
]);
2736 dim
= isl_dim_join(dim1
, dim2
);
2737 grid
[i
][j
] = isl_map_empty(dim
);
2741 for (k
= 0; k
< n
; ++k
) {
2743 j
= group
[2 * k
+ 1];
2744 grid
[i
][j
] = isl_map_union(grid
[i
][j
],
2745 isl_map_from_basic_map(
2746 isl_basic_map_copy(list
[k
])));
2749 floyd_warshall_iterate(grid
, n_group
, exact
);
2751 app
= isl_union_map_empty(isl_map_get_dim(grid
[0][0]));
2753 for (i
= 0; i
< n_group
; ++i
) {
2754 for (j
= 0; j
< n_group
; ++j
)
2755 app
= isl_union_map_add_map(app
, grid
[i
][j
]);
2760 for (i
= 0; i
< 2 * n
; ++i
)
2761 isl_set_free(set
[i
]);
2768 for (i
= 0; i
< n_group
; ++i
) {
2771 for (j
= 0; j
< n_group
; ++j
)
2772 isl_map_free(grid
[i
][j
]);
2777 for (i
= 0; i
< 2 * n
; ++i
)
2778 isl_set_free(set
[i
]);
2785 /* Perform Floyd-Warshall on the given union relation.
2786 * The implementation is very similar to that for non-unions.
2787 * The main difference is that it is applied unconditionally.
2788 * We first extract a list of basic maps from the union map
2789 * and then perform the algorithm on this list.
2791 static __isl_give isl_union_map
*union_floyd_warshall(
2792 __isl_take isl_union_map
*umap
, int *exact
)
2796 isl_basic_map
**list
;
2797 isl_basic_map
**next
;
2801 if (isl_union_map_foreach_map(umap
, inc_count
, &n
) < 0)
2804 ctx
= isl_union_map_get_ctx(umap
);
2805 list
= isl_calloc_array(ctx
, isl_basic_map
*, n
);
2810 if (isl_union_map_foreach_map(umap
, collect_basic_map
, &next
) < 0)
2813 res
= union_floyd_warshall_on_list(ctx
, list
, n
, exact
);
2816 for (i
= 0; i
< n
; ++i
)
2817 isl_basic_map_free(list
[i
]);
2821 isl_union_map_free(umap
);
2825 for (i
= 0; i
< n
; ++i
)
2826 isl_basic_map_free(list
[i
]);
2829 isl_union_map_free(umap
);
2833 /* Decompose the give union relation into strongly connected components.
2834 * The implementation is essentially the same as that of
2835 * construct_power_components with the major difference that all
2836 * operations are performed on union maps.
2838 static __isl_give isl_union_map
*union_components(
2839 __isl_take isl_union_map
*umap
, int *exact
)
2844 isl_basic_map
**list
;
2845 isl_basic_map
**next
;
2846 isl_union_map
*path
= NULL
;
2847 struct basic_map_sort
*s
= NULL
;
2852 if (isl_union_map_foreach_map(umap
, inc_count
, &n
) < 0)
2856 return union_floyd_warshall(umap
, exact
);
2858 ctx
= isl_union_map_get_ctx(umap
);
2859 list
= isl_calloc_array(ctx
, isl_basic_map
*, n
);
2864 if (isl_union_map_foreach_map(umap
, collect_basic_map
, &next
) < 0)
2867 s
= basic_map_sort_init(ctx
, n
, list
);
2874 path
= isl_union_map_empty(isl_union_map_get_dim(umap
));
2876 isl_union_map
*comp
;
2877 isl_union_map
*path_comp
, *path_comb
;
2878 comp
= isl_union_map_empty(isl_union_map_get_dim(umap
));
2879 while (s
->order
[i
] != -1) {
2880 comp
= isl_union_map_add_map(comp
,
2881 isl_map_from_basic_map(
2882 isl_basic_map_copy(list
[s
->order
[i
]])));
2886 path_comp
= union_floyd_warshall(comp
, exact
);
2887 path_comb
= isl_union_map_apply_range(isl_union_map_copy(path
),
2888 isl_union_map_copy(path_comp
));
2889 path
= isl_union_map_union(path
, path_comp
);
2890 path
= isl_union_map_union(path
, path_comb
);
2895 if (c
> 1 && s
->check_closed
&& !*exact
) {
2898 closed
= isl_union_map_is_transitively_closed(path
);
2904 basic_map_sort_free(s
);
2906 for (i
= 0; i
< n
; ++i
)
2907 isl_basic_map_free(list
[i
]);
2911 isl_union_map_free(path
);
2912 return union_floyd_warshall(umap
, exact
);
2915 isl_union_map_free(umap
);
2919 basic_map_sort_free(s
);
2921 for (i
= 0; i
< n
; ++i
)
2922 isl_basic_map_free(list
[i
]);
2925 isl_union_map_free(umap
);
2926 isl_union_map_free(path
);
2930 /* Compute the transitive closure of "umap", or an overapproximation.
2931 * If the result is exact, then *exact is set to 1.
2933 __isl_give isl_union_map
*isl_union_map_transitive_closure(
2934 __isl_take isl_union_map
*umap
, int *exact
)
2944 umap
= isl_union_map_compute_divs(umap
);
2945 umap
= isl_union_map_coalesce(umap
);
2946 closed
= isl_union_map_is_transitively_closed(umap
);
2951 umap
= union_components(umap
, exact
);
2954 isl_union_map_free(umap
);