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"
16 /* Given a map that represents a path with the length of the path
17 * encoded as the difference between the last output coordindate
18 * and the last input coordinate, set this length to either
19 * exactly "length" (if "exactly" is set) or at least "length"
20 * (if "exactly" is not set).
22 static __isl_give isl_map
*set_path_length(__isl_take isl_map
*map
,
23 int exactly
, int length
)
26 struct isl_basic_map
*bmap
;
35 dim
= isl_map_get_dim(map
);
36 d
= isl_dim_size(dim
, isl_dim_in
);
37 nparam
= isl_dim_size(dim
, isl_dim_param
);
38 bmap
= isl_basic_map_alloc_dim(dim
, 0, 1, 1);
40 k
= isl_basic_map_alloc_equality(bmap
);
43 k
= isl_basic_map_alloc_inequality(bmap
);
48 isl_seq_clr(c
, 1 + isl_basic_map_total_dim(bmap
));
49 isl_int_set_si(c
[0], -length
);
50 isl_int_set_si(c
[1 + nparam
+ d
- 1], -1);
51 isl_int_set_si(c
[1 + nparam
+ d
+ d
- 1], 1);
53 bmap
= isl_basic_map_finalize(bmap
);
54 map
= isl_map_intersect(map
, isl_map_from_basic_map(bmap
));
58 isl_basic_map_free(bmap
);
63 /* Check whether the overapproximation of the power of "map" is exactly
64 * the power of "map". Let R be "map" and A_k the overapproximation.
65 * The approximation is exact if
68 * A_k = A_{k-1} \circ R k >= 2
70 * Since A_k is known to be an overapproximation, we only need to check
73 * A_k \subset A_{k-1} \circ R k >= 2
75 * In practice, "app" has an extra input and output coordinate
76 * to encode the length of the path. So, we first need to add
77 * this coordinate to "map" and set the length of the path to
80 static int check_power_exactness(__isl_take isl_map
*map
,
81 __isl_take isl_map
*app
)
87 map
= isl_map_add(map
, isl_dim_in
, 1);
88 map
= isl_map_add(map
, isl_dim_out
, 1);
89 map
= set_path_length(map
, 1, 1);
91 app_1
= set_path_length(isl_map_copy(app
), 1, 1);
93 exact
= isl_map_is_subset(app_1
, map
);
96 if (!exact
|| exact
< 0) {
102 app_1
= set_path_length(isl_map_copy(app
), 0, 1);
103 app_2
= set_path_length(app
, 0, 2);
104 app_1
= isl_map_apply_range(map
, app_1
);
106 exact
= isl_map_is_subset(app_2
, app_1
);
114 /* Check whether the overapproximation of the power of "map" is exactly
115 * the power of "map", possibly after projecting out the power (if "project"
118 * If "project" is set and if "steps" can only result in acyclic paths,
121 * A = R \cup (A \circ R)
123 * where A is the overapproximation with the power projected out, i.e.,
124 * an overapproximation of the transitive closure.
125 * More specifically, since A is known to be an overapproximation, we check
127 * A \subset R \cup (A \circ R)
129 * Otherwise, we check if the power is exact.
131 * Note that "app" has an extra input and output coordinate to encode
132 * the length of the part. If we are only interested in the transitive
133 * closure, then we can simply project out these coordinates first.
135 static int check_exactness(__isl_take isl_map
*map
, __isl_take isl_map
*app
,
143 return check_power_exactness(map
, app
);
145 d
= isl_map_dim(map
, isl_dim_in
);
146 app
= set_path_length(app
, 0, 1);
147 app
= isl_map_project_out(app
, isl_dim_in
, d
, 1);
148 app
= isl_map_project_out(app
, isl_dim_out
, d
, 1);
150 test
= isl_map_apply_range(isl_map_copy(map
), isl_map_copy(app
));
151 test
= isl_map_union(test
, isl_map_copy(map
));
153 exact
= isl_map_is_subset(app
, test
);
168 * The transitive closure implementation is based on the paper
169 * "Computing the Transitive Closure of a Union of Affine Integer
170 * Tuple Relations" by Anna Beletska, Denis Barthou, Wlodzimierz Bielecki and
174 /* Given a set of n offsets v_i (the rows of "steps"), construct a relation
175 * of the given dimension specification (Z^{n+1} -> Z^{n+1})
176 * that maps an element x to any element that can be reached
177 * by taking a non-negative number of steps along any of
178 * the extended offsets v'_i = [v_i 1].
181 * { [x] -> [y] : exists k_i >= 0, y = x + \sum_i k_i v'_i }
183 * For any element in this relation, the number of steps taken
184 * is equal to the difference in the final coordinates.
186 static __isl_give isl_map
*path_along_steps(__isl_take isl_dim
*dim
,
187 __isl_keep isl_mat
*steps
)
190 struct isl_basic_map
*path
= NULL
;
198 d
= isl_dim_size(dim
, isl_dim_in
);
200 nparam
= isl_dim_size(dim
, isl_dim_param
);
202 path
= isl_basic_map_alloc_dim(isl_dim_copy(dim
), n
, d
, n
);
204 for (i
= 0; i
< n
; ++i
) {
205 k
= isl_basic_map_alloc_div(path
);
208 isl_assert(steps
->ctx
, i
== k
, goto error
);
209 isl_int_set_si(path
->div
[k
][0], 0);
212 for (i
= 0; i
< d
; ++i
) {
213 k
= isl_basic_map_alloc_equality(path
);
216 isl_seq_clr(path
->eq
[k
], 1 + isl_basic_map_total_dim(path
));
217 isl_int_set_si(path
->eq
[k
][1 + nparam
+ i
], 1);
218 isl_int_set_si(path
->eq
[k
][1 + nparam
+ d
+ i
], -1);
220 for (j
= 0; j
< n
; ++j
)
221 isl_int_set_si(path
->eq
[k
][1 + nparam
+ 2 * d
+ j
], 1);
223 for (j
= 0; j
< n
; ++j
)
224 isl_int_set(path
->eq
[k
][1 + nparam
+ 2 * d
+ j
],
228 for (i
= 0; i
< n
; ++i
) {
229 k
= isl_basic_map_alloc_inequality(path
);
232 isl_seq_clr(path
->ineq
[k
], 1 + isl_basic_map_total_dim(path
));
233 isl_int_set_si(path
->ineq
[k
][1 + nparam
+ 2 * d
+ i
], 1);
238 path
= isl_basic_map_simplify(path
);
239 path
= isl_basic_map_finalize(path
);
240 return isl_map_from_basic_map(path
);
243 isl_basic_map_free(path
);
252 /* Return PURE_PARAM if only the coefficients of the parameters are non-zero.
253 * Return PURE_VAR if only the coefficients of the set variables are non-zero.
254 * Return MIXED if only the coefficients of the parameters and the set
255 * variables are non-zero and if moreover the parametric constant
256 * can never attain positive values.
257 * Return IMPURE otherwise.
259 static int purity(__isl_keep isl_basic_set
*bset
, isl_int
*c
, int *div_purity
,
270 n_div
= isl_basic_set_dim(bset
, isl_dim_div
);
271 d
= isl_basic_set_dim(bset
, isl_dim_set
);
272 nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
274 for (i
= 0; i
< n_div
; ++i
) {
275 if (isl_int_is_zero(c
[1 + nparam
+ d
+ i
]))
277 switch (div_purity
[i
]) {
278 case PURE_PARAM
: p
= 1; break;
279 case PURE_VAR
: v
= 1; break;
280 default: return IMPURE
;
283 if (!p
&& isl_seq_first_non_zero(c
+ 1, nparam
) == -1)
285 if (!v
&& isl_seq_first_non_zero(c
+ 1 + nparam
, d
) == -1)
290 bset
= isl_basic_set_copy(bset
);
291 bset
= isl_basic_set_cow(bset
);
292 bset
= isl_basic_set_extend_constraints(bset
, 0, 1);
293 k
= isl_basic_set_alloc_inequality(bset
);
296 isl_seq_clr(bset
->ineq
[k
], 1 + isl_basic_set_total_dim(bset
));
297 isl_seq_cpy(bset
->ineq
[k
], c
, 1 + nparam
);
298 for (i
= 0; i
< n_div
; ++i
) {
299 if (div_purity
[i
] != PURE_PARAM
)
301 isl_int_set(bset
->ineq
[k
][1 + nparam
+ d
+ i
],
302 c
[1 + nparam
+ d
+ i
]);
304 isl_int_sub_ui(bset
->ineq
[k
][0], bset
->ineq
[k
][0], 1);
305 empty
= isl_basic_set_is_empty(bset
);
306 isl_basic_set_free(bset
);
308 return empty
< 0 ? -1 : empty
? MIXED
: IMPURE
;
310 isl_basic_set_free(bset
);
314 /* Return an array of integers indicating the type of each div in bset.
315 * If the div is (recursively) defined in terms of only the parameters,
316 * then the type is PURE_PARAM.
317 * If the div is (recursively) defined in terms of only the set variables,
318 * then the type is PURE_VAR.
319 * Otherwise, the type is IMPURE.
321 static __isl_give
int *get_div_purity(__isl_keep isl_basic_set
*bset
)
332 n_div
= isl_basic_set_dim(bset
, isl_dim_div
);
333 d
= isl_basic_set_dim(bset
, isl_dim_set
);
334 nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
336 div_purity
= isl_alloc_array(bset
->ctx
, int, n_div
);
340 for (i
= 0; i
< bset
->n_div
; ++i
) {
342 if (isl_int_is_zero(bset
->div
[i
][0])) {
343 div_purity
[i
] = IMPURE
;
346 if (isl_seq_first_non_zero(bset
->div
[i
] + 2, nparam
) != -1)
348 if (isl_seq_first_non_zero(bset
->div
[i
] + 2 + nparam
, d
) != -1)
350 for (j
= 0; j
< i
; ++j
) {
351 if (isl_int_is_zero(bset
->div
[i
][2 + nparam
+ d
+ j
]))
353 switch (div_purity
[j
]) {
354 case PURE_PARAM
: p
= 1; break;
355 case PURE_VAR
: v
= 1; break;
356 default: p
= v
= 1; break;
359 div_purity
[i
] = v
? p
? IMPURE
: PURE_VAR
: PURE_PARAM
;
365 /* Given a path with the as yet unconstrained length at position "pos",
366 * check if setting the length to zero results in only the identity
369 int empty_path_is_identity(__isl_keep isl_basic_map
*path
, unsigned pos
)
371 isl_basic_map
*test
= NULL
;
372 isl_basic_map
*id
= NULL
;
376 test
= isl_basic_map_copy(path
);
377 test
= isl_basic_map_extend_constraints(test
, 1, 0);
378 k
= isl_basic_map_alloc_equality(test
);
381 isl_seq_clr(test
->eq
[k
], 1 + isl_basic_map_total_dim(test
));
382 isl_int_set_si(test
->eq
[k
][pos
], 1);
383 id
= isl_basic_map_identity(isl_dim_domain(isl_basic_map_get_dim(path
)));
384 is_id
= isl_basic_map_is_subset(test
, id
);
385 isl_basic_map_free(test
);
386 isl_basic_map_free(id
);
389 isl_basic_map_free(test
);
393 __isl_give isl_basic_map
*add_delta_constraints(__isl_take isl_basic_map
*path
,
394 __isl_keep isl_basic_set
*delta
, unsigned off
, unsigned nparam
,
395 unsigned d
, int *div_purity
, int eq
)
398 int n
= eq
? delta
->n_eq
: delta
->n_ineq
;
399 isl_int
**delta_c
= eq
? delta
->eq
: delta
->ineq
;
400 isl_int
**path_c
= eq
? path
->eq
: path
->ineq
;
403 n_div
= isl_basic_set_dim(delta
, isl_dim_div
);
405 for (i
= 0; i
< n
; ++i
) {
406 int p
= purity(delta
, delta_c
[i
], div_purity
, eq
);
412 k
= isl_basic_map_alloc_equality(path
);
414 k
= isl_basic_map_alloc_inequality(path
);
417 isl_seq_clr(path_c
[k
], 1 + isl_basic_map_total_dim(path
));
419 isl_seq_cpy(path_c
[k
] + off
,
420 delta_c
[i
] + 1 + nparam
, d
);
421 isl_int_set(path_c
[k
][off
+ d
], delta_c
[i
][0]);
422 } else if (p
== PURE_PARAM
) {
423 isl_seq_cpy(path_c
[k
], delta_c
[i
], 1 + nparam
);
425 isl_seq_cpy(path_c
[k
] + off
,
426 delta_c
[i
] + 1 + nparam
, d
);
427 isl_seq_cpy(path_c
[k
], delta_c
[i
], 1 + nparam
);
429 isl_seq_cpy(path_c
[k
] + off
- n_div
,
430 delta_c
[i
] + 1 + nparam
+ d
, n_div
);
435 isl_basic_map_free(path
);
439 /* Given a set of offsets "delta", construct a relation of the
440 * given dimension specification (Z^{n+1} -> Z^{n+1}) that
441 * is an overapproximation of the relations that
442 * maps an element x to any element that can be reached
443 * by taking a non-negative number of steps along any of
444 * the elements in "delta".
445 * That is, construct an approximation of
447 * { [x] -> [y] : exists f \in \delta, k \in Z :
448 * y = x + k [f, 1] and k >= 0 }
450 * For any element in this relation, the number of steps taken
451 * is equal to the difference in the final coordinates.
453 * In particular, let delta be defined as
455 * \delta = [p] -> { [x] : A x + a >= and B p + b >= 0 and
456 * C x + C'p + c >= 0 and
457 * D x + D'p + d >= 0 }
459 * where the constraints C x + C'p + c >= 0 are such that the parametric
460 * constant term of each constraint j, "C_j x + C'_j p + c_j",
461 * can never attain positive values, then the relation is constructed as
463 * { [x] -> [y] : exists [f, k] \in Z^{n+1} : y = x + f and
464 * A f + k a >= 0 and B p + b >= 0 and
465 * C f + C'p + c >= 0 and k >= 1 }
466 * union { [x] -> [x] }
468 * If the zero-length paths happen to correspond exactly to the identity
469 * mapping, then we return
471 * { [x] -> [y] : exists [f, k] \in Z^{n+1} : y = x + f and
472 * A f + k a >= 0 and B p + b >= 0 and
473 * C f + C'p + c >= 0 and k >= 0 }
477 * Existentially quantified variables in \delta are handled by
478 * classifying them as independent of the parameters, purely
479 * parameter dependent and others. Constraints containing
480 * any of the other existentially quantified variables are removed.
481 * This is safe, but leads to an additional overapproximation.
483 static __isl_give isl_map
*path_along_delta(__isl_take isl_dim
*dim
,
484 __isl_take isl_basic_set
*delta
)
486 isl_basic_map
*path
= NULL
;
493 int *div_purity
= NULL
;
497 n_div
= isl_basic_set_dim(delta
, isl_dim_div
);
498 d
= isl_basic_set_dim(delta
, isl_dim_set
);
499 nparam
= isl_basic_set_dim(delta
, isl_dim_param
);
500 path
= isl_basic_map_alloc_dim(isl_dim_copy(dim
), n_div
+ d
+ 1,
501 d
+ 1 + delta
->n_eq
, delta
->n_ineq
+ 1);
502 off
= 1 + nparam
+ 2 * (d
+ 1) + n_div
;
504 for (i
= 0; i
< n_div
+ d
+ 1; ++i
) {
505 k
= isl_basic_map_alloc_div(path
);
508 isl_int_set_si(path
->div
[k
][0], 0);
511 for (i
= 0; i
< d
+ 1; ++i
) {
512 k
= isl_basic_map_alloc_equality(path
);
515 isl_seq_clr(path
->eq
[k
], 1 + isl_basic_map_total_dim(path
));
516 isl_int_set_si(path
->eq
[k
][1 + nparam
+ i
], 1);
517 isl_int_set_si(path
->eq
[k
][1 + nparam
+ d
+ 1 + i
], -1);
518 isl_int_set_si(path
->eq
[k
][off
+ i
], 1);
521 div_purity
= get_div_purity(delta
);
525 path
= add_delta_constraints(path
, delta
, off
, nparam
, d
, div_purity
, 1);
526 path
= add_delta_constraints(path
, delta
, off
, nparam
, d
, div_purity
, 0);
528 is_id
= empty_path_is_identity(path
, off
+ d
);
532 k
= isl_basic_map_alloc_inequality(path
);
535 isl_seq_clr(path
->ineq
[k
], 1 + isl_basic_map_total_dim(path
));
537 isl_int_set_si(path
->ineq
[k
][0], -1);
538 isl_int_set_si(path
->ineq
[k
][off
+ d
], 1);
541 isl_basic_set_free(delta
);
542 path
= isl_basic_map_finalize(path
);
545 return isl_map_from_basic_map(path
);
547 return isl_basic_map_union(path
,
548 isl_basic_map_identity(isl_dim_domain(dim
)));
552 isl_basic_set_free(delta
);
553 isl_basic_map_free(path
);
557 /* Given a dimenion specification Z^{n+1} -> Z^{n+1} and a parameter "param",
558 * construct a map that equates the parameter to the difference
559 * in the final coordinates and imposes that this difference is positive.
562 * { [x,x_s] -> [y,y_s] : k = y_s - x_s > 0 }
564 static __isl_give isl_map
*equate_parameter_to_length(__isl_take isl_dim
*dim
,
567 struct isl_basic_map
*bmap
;
572 d
= isl_dim_size(dim
, isl_dim_in
);
573 nparam
= isl_dim_size(dim
, isl_dim_param
);
574 bmap
= isl_basic_map_alloc_dim(dim
, 0, 1, 1);
575 k
= isl_basic_map_alloc_equality(bmap
);
578 isl_seq_clr(bmap
->eq
[k
], 1 + isl_basic_map_total_dim(bmap
));
579 isl_int_set_si(bmap
->eq
[k
][1 + param
], -1);
580 isl_int_set_si(bmap
->eq
[k
][1 + nparam
+ d
- 1], -1);
581 isl_int_set_si(bmap
->eq
[k
][1 + nparam
+ d
+ d
- 1], 1);
583 k
= isl_basic_map_alloc_inequality(bmap
);
586 isl_seq_clr(bmap
->ineq
[k
], 1 + isl_basic_map_total_dim(bmap
));
587 isl_int_set_si(bmap
->ineq
[k
][1 + param
], 1);
588 isl_int_set_si(bmap
->ineq
[k
][0], -1);
590 bmap
= isl_basic_map_finalize(bmap
);
591 return isl_map_from_basic_map(bmap
);
593 isl_basic_map_free(bmap
);
597 /* Check whether "path" is acyclic, where the last coordinates of domain
598 * and range of path encode the number of steps taken.
599 * That is, check whether
601 * { d | d = y - x and (x,y) in path }
603 * does not contain any element with positive last coordinate (positive length)
604 * and zero remaining coordinates (cycle).
606 static int is_acyclic(__isl_take isl_map
*path
)
611 struct isl_set
*delta
;
613 delta
= isl_map_deltas(path
);
614 dim
= isl_set_dim(delta
, isl_dim_set
);
615 for (i
= 0; i
< dim
; ++i
) {
617 delta
= isl_set_lower_bound_si(delta
, isl_dim_set
, i
, 1);
619 delta
= isl_set_fix_si(delta
, isl_dim_set
, i
, 0);
622 acyclic
= isl_set_is_empty(delta
);
628 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
629 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
630 * construct a map that is an overapproximation of the map
631 * that takes an element from the space D \times Z to another
632 * element from the same space, such that the first n coordinates of the
633 * difference between them is a sum of differences between images
634 * and pre-images in one of the R_i and such that the last coordinate
635 * is equal to the number of steps taken.
638 * \Delta_i = { y - x | (x, y) in R_i }
640 * then the constructed map is an overapproximation of
642 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
643 * d = (\sum_i k_i \delta_i, \sum_i k_i) }
645 * The elements of the singleton \Delta_i's are collected as the
646 * rows of the steps matrix. For all these \Delta_i's together,
647 * a single path is constructed.
648 * For each of the other \Delta_i's, we compute an overapproximation
649 * of the paths along elements of \Delta_i.
650 * Since each of these paths performs an addition, composition is
651 * symmetric and we can simply compose all resulting paths in any order.
653 static __isl_give isl_map
*construct_extended_path(__isl_take isl_dim
*dim
,
654 __isl_keep isl_map
*map
, int *project
)
656 struct isl_mat
*steps
= NULL
;
657 struct isl_map
*path
= NULL
;
661 d
= isl_map_dim(map
, isl_dim_in
);
663 path
= isl_map_identity(isl_dim_domain(isl_dim_copy(dim
)));
665 steps
= isl_mat_alloc(map
->ctx
, map
->n
, d
);
670 for (i
= 0; i
< map
->n
; ++i
) {
671 struct isl_basic_set
*delta
;
673 delta
= isl_basic_map_deltas(isl_basic_map_copy(map
->p
[i
]));
675 for (j
= 0; j
< d
; ++j
) {
678 fixed
= isl_basic_set_fast_dim_is_fixed(delta
, j
,
681 isl_basic_set_free(delta
);
690 path
= isl_map_apply_range(path
,
691 path_along_delta(isl_dim_copy(dim
), delta
));
692 path
= isl_map_coalesce(path
);
694 isl_basic_set_free(delta
);
701 path
= isl_map_apply_range(path
,
702 path_along_steps(isl_dim_copy(dim
), steps
));
705 if (project
&& *project
) {
706 *project
= is_acyclic(isl_map_copy(path
));
721 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
722 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
723 * construct a map that is the union of the identity map and
724 * an overapproximation of the map
725 * that takes an element from the dom R \times Z to an
726 * element from ran R \times Z, such that the first n coordinates of the
727 * difference between them is a sum of differences between images
728 * and pre-images in one of the R_i and such that the last coordinate
729 * is equal to the number of steps taken.
732 * \Delta_i = { y - x | (x, y) in R_i }
734 * then the constructed map is an overapproximation of
736 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
737 * d = (\sum_i k_i \delta_i, \sum_i k_i) and
738 * x in dom R and x + d in ran R } union
741 static __isl_give isl_map
*construct_component(__isl_take isl_dim
*dim
,
742 __isl_keep isl_map
*map
, int *exact
, int project
)
744 struct isl_set
*domain
= NULL
;
745 struct isl_set
*range
= NULL
;
746 struct isl_set
*overlap
;
747 struct isl_map
*app
= NULL
;
748 struct isl_map
*path
= NULL
;
750 domain
= isl_map_domain(isl_map_copy(map
));
751 domain
= isl_set_coalesce(domain
);
752 range
= isl_map_range(isl_map_copy(map
));
753 range
= isl_set_coalesce(range
);
754 overlap
= isl_set_intersect(isl_set_copy(domain
), isl_set_copy(range
));
755 if (isl_set_is_empty(overlap
) == 1) {
756 isl_set_free(domain
);
758 isl_set_free(overlap
);
760 map
= isl_map_copy(map
);
761 map
= isl_map_add(map
, isl_dim_in
, 1);
762 map
= isl_map_add(map
, isl_dim_out
, 1);
763 map
= set_path_length(map
, 1, 1);
764 map
= isl_map_union(map
, isl_map_identity(isl_dim_domain(dim
)));
767 isl_set_free(overlap
);
768 app
= isl_map_from_domain_and_range(domain
, range
);
769 app
= isl_map_add(app
, isl_dim_in
, 1);
770 app
= isl_map_add(app
, isl_dim_out
, 1);
772 path
= construct_extended_path(isl_dim_copy(dim
), map
,
773 exact
&& *exact
? &project
: NULL
);
774 app
= isl_map_intersect(app
, path
);
776 if (exact
&& *exact
&&
777 (*exact
= check_exactness(isl_map_copy(map
), isl_map_copy(app
),
781 return isl_map_union(app
, isl_map_identity(isl_dim_domain(dim
)));
788 /* Structure for representing the nodes in the graph being traversed
789 * using Tarjan's algorithm.
790 * index represents the order in which nodes are visited.
791 * min_index is the index of the root of a (sub)component.
792 * on_stack indicates whether the node is currently on the stack.
794 struct basic_map_sort_node
{
799 /* Structure for representing the graph being traversed
800 * using Tarjan's algorithm.
801 * len is the number of nodes
802 * node is an array of nodes
803 * stack contains the nodes on the path from the root to the current node
804 * sp is the stack pointer
805 * index is the index of the last node visited
806 * order contains the elements of the components separated by -1
807 * op represents the current position in order
809 struct basic_map_sort
{
811 struct basic_map_sort_node
*node
;
819 static void basic_map_sort_free(struct basic_map_sort
*s
)
829 static struct basic_map_sort
*basic_map_sort_alloc(struct isl_ctx
*ctx
, int len
)
831 struct basic_map_sort
*s
;
834 s
= isl_calloc_type(ctx
, struct basic_map_sort
);
838 s
->node
= isl_alloc_array(ctx
, struct basic_map_sort_node
, len
);
841 for (i
= 0; i
< len
; ++i
)
842 s
->node
[i
].index
= -1;
843 s
->stack
= isl_alloc_array(ctx
, int, len
);
846 s
->order
= isl_alloc_array(ctx
, int, 2 * len
);
856 basic_map_sort_free(s
);
860 /* Check whether in the computation of the transitive closure
861 * "bmap1" (R_1) should follow (or be part of the same component as)
864 * That is check whether
872 * If so, then there is no reason for R_1 to immediately follow R_2
875 static int basic_map_follows(__isl_keep isl_basic_map
*bmap1
,
876 __isl_keep isl_basic_map
*bmap2
)
878 struct isl_map
*map12
= NULL
;
879 struct isl_map
*map21
= NULL
;
882 map21
= isl_map_from_basic_map(
883 isl_basic_map_apply_range(
884 isl_basic_map_copy(bmap2
),
885 isl_basic_map_copy(bmap1
)));
886 subset
= isl_map_is_empty(map21
);
894 map12
= isl_map_from_basic_map(
895 isl_basic_map_apply_range(
896 isl_basic_map_copy(bmap1
),
897 isl_basic_map_copy(bmap2
)));
899 subset
= isl_map_is_subset(map21
, map12
);
904 return subset
< 0 ? -1 : !subset
;
910 /* Perform Tarjan's algorithm for computing the strongly connected components
911 * in the graph with the disjuncts of "map" as vertices and with an
912 * edge between any pair of disjuncts such that the first has
913 * to be applied after the second.
915 static int power_components_tarjan(struct basic_map_sort
*s
,
916 __isl_keep isl_map
*map
, int i
)
920 s
->node
[i
].index
= s
->index
;
921 s
->node
[i
].min_index
= s
->index
;
922 s
->node
[i
].on_stack
= 1;
924 s
->stack
[s
->sp
++] = i
;
926 for (j
= s
->len
- 1; j
>= 0; --j
) {
931 if (s
->node
[j
].index
>= 0 &&
932 (!s
->node
[j
].on_stack
||
933 s
->node
[j
].index
> s
->node
[i
].min_index
))
936 f
= basic_map_follows(map
->p
[i
], map
->p
[j
]);
942 if (s
->node
[j
].index
< 0) {
943 power_components_tarjan(s
, map
, j
);
944 if (s
->node
[j
].min_index
< s
->node
[i
].min_index
)
945 s
->node
[i
].min_index
= s
->node
[j
].min_index
;
946 } else if (s
->node
[j
].index
< s
->node
[i
].min_index
)
947 s
->node
[i
].min_index
= s
->node
[j
].index
;
950 if (s
->node
[i
].index
!= s
->node
[i
].min_index
)
954 j
= s
->stack
[--s
->sp
];
955 s
->node
[j
].on_stack
= 0;
956 s
->order
[s
->op
++] = j
;
958 s
->order
[s
->op
++] = -1;
963 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
964 * and a dimension specification (Z^{n+1} -> Z^{n+1}),
965 * construct a map that is the union of the identity map and
966 * an overapproximation of the map
967 * that takes an element from the dom R \times Z to an
968 * element from ran R \times Z, such that the first n coordinates of the
969 * difference between them is a sum of differences between images
970 * and pre-images in one of the R_i and such that the last coordinate
971 * is equal to the number of steps taken.
974 * \Delta_i = { y - x | (x, y) in R_i }
976 * then the constructed map is an overapproximation of
978 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
979 * d = (\sum_i k_i \delta_i, \sum_i k_i) and
980 * x in dom R and x + d in ran R } union
983 * We first split the map into strongly connected components, perform
984 * the above on each component and the join the results in the correct
985 * order. The power of each of the components needs to be extended
986 * with the identity map because a path in the global result need
987 * not go through every component.
988 * The final result will then also contain the identity map, but
989 * this part will be removed when the length of the path is forced
990 * to be strictly positive.
992 static __isl_give isl_map
*construct_power_components(__isl_take isl_dim
*dim
,
993 __isl_keep isl_map
*map
, int *exact
, int project
)
996 struct isl_map
*path
= NULL
;
997 struct basic_map_sort
*s
= NULL
;
1002 return construct_component(dim
, map
, exact
, project
);
1004 s
= basic_map_sort_alloc(map
->ctx
, map
->n
);
1007 for (i
= map
->n
- 1; i
>= 0; --i
) {
1008 if (s
->node
[i
].index
>= 0)
1010 if (power_components_tarjan(s
, map
, i
) < 0)
1016 path
= isl_map_identity(isl_dim_domain(isl_dim_copy(dim
)));
1018 struct isl_map
*comp
;
1019 comp
= isl_map_alloc_dim(isl_map_get_dim(map
), n
, 0);
1020 while (s
->order
[i
] != -1) {
1021 comp
= isl_map_add_basic_map(comp
,
1022 isl_basic_map_copy(map
->p
[s
->order
[i
]]));
1026 path
= isl_map_apply_range(path
,
1027 construct_component(isl_dim_copy(dim
), comp
,
1033 basic_map_sort_free(s
);
1038 basic_map_sort_free(s
);
1043 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D,
1044 * construct a map that is an overapproximation of the map
1045 * that takes an element from the space D to another
1046 * element from the same space, such that the difference between
1047 * them is a strictly positive sum of differences between images
1048 * and pre-images in one of the R_i.
1049 * The number of differences in the sum is equated to parameter "param".
1052 * \Delta_i = { y - x | (x, y) in R_i }
1054 * then the constructed map is an overapproximation of
1056 * { (x) -> (x + d) | \exists k_i >= 0, \delta_i \in \Delta_i :
1057 * d = \sum_i k_i \delta_i and k = \sum_i k_i > 0 }
1059 * We first construct an extended mapping with an extra coordinate
1060 * that indicates the number of steps taken. In particular,
1061 * the difference in the last coordinate is equal to the number
1062 * of steps taken to move from a domain element to the corresponding
1064 * In the final step, this difference is equated to the parameter "param"
1065 * and made positive. The extra coordinates are subsequently projected out.
1067 static __isl_give isl_map
*construct_power(__isl_keep isl_map
*map
,
1068 unsigned param
, int *exact
, int project
)
1070 struct isl_map
*app
= NULL
;
1071 struct isl_map
*diff
;
1072 struct isl_dim
*dim
= NULL
;
1078 dim
= isl_map_get_dim(map
);
1080 d
= isl_dim_size(dim
, isl_dim_in
);
1081 dim
= isl_dim_add(dim
, isl_dim_in
, 1);
1082 dim
= isl_dim_add(dim
, isl_dim_out
, 1);
1084 app
= construct_power_components(isl_dim_copy(dim
), map
,
1087 diff
= equate_parameter_to_length(dim
, param
);
1088 app
= isl_map_intersect(app
, diff
);
1089 app
= isl_map_project_out(app
, isl_dim_in
, d
, 1);
1090 app
= isl_map_project_out(app
, isl_dim_out
, d
, 1);
1095 /* Compute the positive powers of "map", or an overapproximation.
1096 * The power is given by parameter "param". If the result is exact,
1097 * then *exact is set to 1.
1098 * If project is set, then we are actually interested in the transitive
1099 * closure, so we can use a more relaxed exactness check.
1101 static __isl_give isl_map
*map_power(__isl_take isl_map
*map
, unsigned param
,
1102 int *exact
, int project
)
1104 struct isl_map
*app
= NULL
;
1109 map
= isl_map_coalesce(map
);
1113 if (isl_map_fast_is_empty(map
))
1116 isl_assert(map
->ctx
, param
< isl_map_dim(map
, isl_dim_param
), goto error
);
1117 isl_assert(map
->ctx
,
1118 isl_map_dim(map
, isl_dim_in
) == isl_map_dim(map
, isl_dim_out
),
1121 app
= construct_power(map
, param
, exact
, project
);
1131 /* Compute the positive powers of "map", or an overapproximation.
1132 * The power is given by parameter "param". If the result is exact,
1133 * then *exact is set to 1.
1135 __isl_give isl_map
*isl_map_power(__isl_take isl_map
*map
, unsigned param
,
1138 return map_power(map
, param
, exact
, 0);
1141 /* Check whether equality i of bset is a pure stride constraint
1142 * on a single dimensions, i.e., of the form
1146 * with k a constant and e an existentially quantified variable.
1148 static int is_eq_stride(__isl_keep isl_basic_set
*bset
, int i
)
1160 if (!isl_int_is_zero(bset
->eq
[i
][0]))
1163 nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
1164 d
= isl_basic_set_dim(bset
, isl_dim_set
);
1165 n_div
= isl_basic_set_dim(bset
, isl_dim_div
);
1167 if (isl_seq_first_non_zero(bset
->eq
[i
] + 1, nparam
) != -1)
1169 pos1
= isl_seq_first_non_zero(bset
->eq
[i
] + 1 + nparam
, d
);
1172 if (isl_seq_first_non_zero(bset
->eq
[i
] + 1 + nparam
+ pos1
+ 1,
1173 d
- pos1
- 1) != -1)
1176 pos2
= isl_seq_first_non_zero(bset
->eq
[i
] + 1 + nparam
+ d
, n_div
);
1179 if (isl_seq_first_non_zero(bset
->eq
[i
] + 1 + nparam
+ d
+ pos2
+ 1,
1180 n_div
- pos2
- 1) != -1)
1182 if (!isl_int_is_one(bset
->eq
[i
][1 + nparam
+ pos1
]) &&
1183 !isl_int_is_negone(bset
->eq
[i
][1 + nparam
+ pos1
]))
1189 /* Given a map, compute the smallest superset of this map that is of the form
1191 * { i -> j : L <= j - i <= U and exists a_p: j_p - i_p = M_p a_p }
1193 * (where p ranges over the (non-parametric) dimensions),
1194 * compute the transitive closure of this map, i.e.,
1196 * { i -> j : exists k > 0:
1197 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
1199 * and intersect domain and range of this transitive closure with
1200 * domain and range of the original map.
1202 * If with_id is set, then try to include as much of the identity mapping
1203 * as possible, by computing
1205 * { i -> j : exists k >= 0:
1206 * k L <= j - i <= k U and exists a: j_p - i_p = M_p a_p }
1208 * instead (i.e., allow k = 0) and by intersecting domain and range
1209 * with the union of the domain and the range of the original map.
1211 * In practice, we compute the difference set
1213 * delta = { j - i | i -> j in map },
1215 * look for stride constraint on the individual dimensions and compute
1216 * (constant) lower and upper bounds for each individual dimension,
1217 * adding a constraint for each bound not equal to infinity.
1219 static __isl_give isl_map
*box_closure(__isl_take isl_map
*map
, int with_id
)
1228 isl_set
*domain
= NULL
;
1229 isl_set
*range
= NULL
;
1230 isl_map
*app
= NULL
;
1231 isl_basic_set
*aff
= NULL
;
1232 isl_basic_map
*bmap
= NULL
;
1233 isl_vec
*obj
= NULL
;
1238 delta
= isl_map_deltas(isl_map_copy(map
));
1240 aff
= isl_set_affine_hull(isl_set_copy(delta
));
1243 dim
= isl_map_get_dim(map
);
1244 d
= isl_dim_size(dim
, isl_dim_in
);
1245 nparam
= isl_dim_size(dim
, isl_dim_param
);
1246 total
= isl_dim_total(dim
);
1247 bmap
= isl_basic_map_alloc_dim(dim
,
1248 aff
->n_div
+ 1, aff
->n_div
, 2 * d
+ 1);
1249 for (i
= 0; i
< aff
->n_div
+ 1; ++i
) {
1250 k
= isl_basic_map_alloc_div(bmap
);
1253 isl_int_set_si(bmap
->div
[k
][0], 0);
1255 for (i
= 0; i
< aff
->n_eq
; ++i
) {
1256 if (!is_eq_stride(aff
, i
))
1258 k
= isl_basic_map_alloc_equality(bmap
);
1261 isl_seq_clr(bmap
->eq
[k
], 1 + nparam
);
1262 isl_seq_cpy(bmap
->eq
[k
] + 1 + nparam
+ d
,
1263 aff
->eq
[i
] + 1 + nparam
, d
);
1264 isl_seq_neg(bmap
->eq
[k
] + 1 + nparam
,
1265 aff
->eq
[i
] + 1 + nparam
, d
);
1266 isl_seq_cpy(bmap
->eq
[k
] + 1 + nparam
+ 2 * d
,
1267 aff
->eq
[i
] + 1 + nparam
+ d
, aff
->n_div
);
1268 isl_int_set_si(bmap
->eq
[k
][1 + total
+ aff
->n_div
], 0);
1270 obj
= isl_vec_alloc(map
->ctx
, 1 + nparam
+ d
);
1273 isl_seq_clr(obj
->el
, 1 + nparam
+ d
);
1274 for (i
= 0; i
< d
; ++ i
) {
1275 enum isl_lp_result res
;
1277 isl_int_set_si(obj
->el
[1 + nparam
+ i
], 1);
1279 res
= isl_set_solve_lp(delta
, 0, obj
->el
, map
->ctx
->one
, &opt
,
1281 if (res
== isl_lp_error
)
1283 if (res
== isl_lp_ok
) {
1284 k
= isl_basic_map_alloc_inequality(bmap
);
1287 isl_seq_clr(bmap
->ineq
[k
],
1288 1 + nparam
+ 2 * d
+ bmap
->n_div
);
1289 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ i
], -1);
1290 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ d
+ i
], 1);
1291 isl_int_neg(bmap
->ineq
[k
][1 + nparam
+ 2 * d
+ aff
->n_div
], opt
);
1294 res
= isl_set_solve_lp(delta
, 1, obj
->el
, map
->ctx
->one
, &opt
,
1296 if (res
== isl_lp_error
)
1298 if (res
== isl_lp_ok
) {
1299 k
= isl_basic_map_alloc_inequality(bmap
);
1302 isl_seq_clr(bmap
->ineq
[k
],
1303 1 + nparam
+ 2 * d
+ bmap
->n_div
);
1304 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ i
], 1);
1305 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ d
+ i
], -1);
1306 isl_int_set(bmap
->ineq
[k
][1 + nparam
+ 2 * d
+ aff
->n_div
], opt
);
1309 isl_int_set_si(obj
->el
[1 + nparam
+ i
], 0);
1311 k
= isl_basic_map_alloc_inequality(bmap
);
1314 isl_seq_clr(bmap
->ineq
[k
],
1315 1 + nparam
+ 2 * d
+ bmap
->n_div
);
1317 isl_int_set_si(bmap
->ineq
[k
][0], -1);
1318 isl_int_set_si(bmap
->ineq
[k
][1 + nparam
+ 2 * d
+ aff
->n_div
], 1);
1320 domain
= isl_map_domain(isl_map_copy(map
));
1321 domain
= isl_set_coalesce(domain
);
1322 range
= isl_map_range(isl_map_copy(map
));
1323 range
= isl_set_coalesce(range
);
1325 domain
= isl_set_union(domain
, range
);
1326 domain
= isl_set_coalesce(domain
);
1327 range
= isl_set_copy(domain
);
1329 app
= isl_map_from_domain_and_range(domain
, range
);
1332 isl_basic_set_free(aff
);
1334 bmap
= isl_basic_map_finalize(bmap
);
1335 isl_set_free(delta
);
1338 map
= isl_map_from_basic_map(bmap
);
1339 map
= isl_map_intersect(map
, app
);
1344 isl_basic_map_free(bmap
);
1345 isl_basic_set_free(aff
);
1347 isl_set_free(delta
);
1352 /* Check whether app is the transitive closure of map.
1353 * In particular, check that app is acyclic and, if so,
1356 * app \subset (map \cup (map \circ app))
1358 static int check_exactness_omega(__isl_keep isl_map
*map
,
1359 __isl_keep isl_map
*app
)
1363 int is_empty
, is_exact
;
1367 delta
= isl_map_deltas(isl_map_copy(app
));
1368 d
= isl_set_dim(delta
, isl_dim_set
);
1369 for (i
= 0; i
< d
; ++i
)
1370 delta
= isl_set_fix_si(delta
, isl_dim_set
, i
, 0);
1371 is_empty
= isl_set_is_empty(delta
);
1372 isl_set_free(delta
);
1378 test
= isl_map_apply_range(isl_map_copy(app
), isl_map_copy(map
));
1379 test
= isl_map_union(test
, isl_map_copy(map
));
1380 is_exact
= isl_map_is_subset(app
, test
);
1386 /* Check if basic map M_i can be combined with all the other
1387 * basic maps such that
1391 * can be computed as
1393 * M_i \cup (\cup_{j \ne i} M_i^* \circ M_j \circ M_i^*)^+
1395 * In particular, check if we can compute a compact representation
1398 * M_i^* \circ M_j \circ M_i^*
1401 * Let M_i^? be an extension of M_i^+ that allows paths
1402 * of length zero, i.e., the result of box_closure(., 1).
1403 * The criterion, as proposed by Kelly et al., is that
1404 * id = M_i^? - M_i^+ can be represented as a basic map
1407 * id \circ M_j \circ id = M_j
1411 * If this function returns 1, then tc and qc are set to
1412 * M_i^+ and M_i^?, respectively.
1414 static int can_be_split_off(__isl_keep isl_map
*map
, int i
,
1415 __isl_give isl_map
**tc
, __isl_give isl_map
**qc
)
1417 isl_map
*map_i
, *id
;
1420 map_i
= isl_map_from_basic_map(isl_basic_map_copy(map
->p
[i
]));
1421 *tc
= box_closure(isl_map_copy(map_i
), 0);
1422 *qc
= box_closure(map_i
, 1);
1423 id
= isl_map_subtract(isl_map_copy(*qc
), isl_map_copy(*tc
));
1427 if (id
->n
!= 1 || (*qc
)->n
!= 1)
1430 for (j
= 0; j
< map
->n
; ++j
) {
1431 isl_map
*map_j
, *test
;
1436 map_j
= isl_map_from_basic_map(
1437 isl_basic_map_copy(map
->p
[j
]));
1438 test
= isl_map_apply_range(isl_map_copy(id
),
1439 isl_map_copy(map_j
));
1440 test
= isl_map_apply_range(test
, isl_map_copy(id
));
1441 is_ok
= isl_map_is_equal(test
, map_j
);
1442 isl_map_free(map_j
);
1470 /* Compute an overapproximation of the transitive closure of "map"
1471 * using a variation of the algorithm from
1472 * "Transitive Closure of Infinite Graphs and its Applications"
1475 * We first check whether we can can split of any basic map M_i and
1482 * M_i \cup (\cup_{j \ne i} M_i^* \circ M_j \circ M_i^*)^+
1484 * using a recursive call on the remaining map.
1486 * If not, we simply call box_closure on the whole map.
1488 static __isl_give isl_map
*compute_closure_omega(__isl_take isl_map
*map
)
1495 return box_closure(map
, 0);
1497 map
= isl_map_cow(map
);
1501 for (i
= 0; i
< map
->n
; ++i
) {
1504 ok
= can_be_split_off(map
, i
, &tc
, &qc
);
1510 isl_basic_map_free(map
->p
[i
]);
1511 if (i
!= map
->n
- 1)
1512 map
->p
[i
] = map
->p
[map
->n
- 1];
1515 map
= isl_map_apply_range(isl_map_copy(qc
), map
);
1516 map
= isl_map_apply_range(map
, qc
);
1518 return isl_map_union(tc
, compute_closure_omega(map
));
1521 return box_closure(map
, 0);
1527 /* Compute an overapproximation of the transitive closure of "map"
1528 * using a variation of the algorithm from
1529 * "Transitive Closure of Infinite Graphs and its Applications"
1530 * by Kelly et al. and check whether the result is definitely exact.
1532 static __isl_give isl_map
*transitive_closure_omega(__isl_take isl_map
*map
,
1537 app
= compute_closure_omega(isl_map_copy(map
));
1540 *exact
= check_exactness_omega(map
, app
);
1546 /* Compute the transitive closure of "map", or an overapproximation.
1547 * If the result is exact, then *exact is set to 1.
1548 * Simply compute the powers of map and then project out the parameter
1549 * describing the power.
1551 __isl_give isl_map
*isl_map_transitive_closure(__isl_take isl_map
*map
,
1559 if (map
->ctx
->opt
->closure
== ISL_CLOSURE_OMEGA
)
1560 return transitive_closure_omega(map
, exact
);
1562 param
= isl_map_dim(map
, isl_dim_param
);
1563 map
= isl_map_add(map
, isl_dim_param
, 1);
1564 map
= map_power(map
, param
, exact
, 1);
1565 map
= isl_map_project_out(map
, isl_dim_param
, param
, 1);