File: | build/source/polly/lib/External/isl/isl_test.c |
Warning: | line 8024, column 12 The left operand of '<' is a garbage value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* |
2 | * Copyright 2008-2009 Katholieke Universiteit Leuven |
3 | * Copyright 2010 INRIA Saclay |
4 | * Copyright 2012-2013 Ecole Normale Superieure |
5 | * Copyright 2014 INRIA Rocquencourt |
6 | * Copyright 2022 Cerebras Systems |
7 | * |
8 | * Use of this software is governed by the MIT license |
9 | * |
10 | * Written by Sven Verdoolaege, K.U.Leuven, Departement |
11 | * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium |
12 | * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite, |
13 | * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France |
14 | * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France |
15 | * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt, |
16 | * B.P. 105 - 78153 Le Chesnay, France |
17 | * and Cerebras Systems, 1237 E Arques Ave, Sunnyvale, CA, USA |
18 | */ |
19 | |
20 | #include <assert.h> |
21 | #include <stdio.h> |
22 | #include <limits.h> |
23 | #include <isl_ctx_private.h> |
24 | #include <isl_map_private.h> |
25 | #include <isl_aff_private.h> |
26 | #include <isl_space_private.h> |
27 | #include <isl/id.h> |
28 | #include <isl/set.h> |
29 | #include <isl/flow.h> |
30 | #include <isl_constraint_private.h> |
31 | #include <isl/polynomial.h> |
32 | #include <isl/union_set.h> |
33 | #include <isl/union_map.h> |
34 | #include <isl_factorization.h> |
35 | #include <isl/schedule.h> |
36 | #include <isl/schedule_node.h> |
37 | #include <isl_options_private.h> |
38 | #include <isl_vertices_private.h> |
39 | #include <isl/ast_build.h> |
40 | #include <isl/val.h> |
41 | #include <isl/ilp.h> |
42 | #include <isl_ast_build_expr.h> |
43 | #include <isl/options.h> |
44 | |
45 | #include "isl_srcdir.c" |
46 | |
47 | #define ARRAY_SIZE(array)(sizeof(array)/sizeof(*array)) (sizeof(array)/sizeof(*array)) |
48 | |
49 | static char *get_filename(isl_ctx *ctx, const char *name, const char *suffix) { |
50 | char *filename; |
51 | int length; |
52 | char *pattern = "%s/test_inputs/%s.%s"; |
53 | |
54 | length = strlen(pattern) - 6 + strlen(srcdir) + strlen(name) |
55 | + strlen(suffix) + 1; |
56 | filename = isl_alloc_array(ctx, char, length)((char *)isl_malloc_or_die(ctx, (length)*sizeof(char))); |
57 | |
58 | if (!filename) |
59 | return NULL((void*)0); |
60 | |
61 | sprintf(filename, pattern, srcdir, name, suffix)__builtin___sprintf_chk (filename, 2 - 1, __builtin_object_size (filename, 2 > 1), pattern, srcdir, name, suffix); |
62 | |
63 | return filename; |
64 | } |
65 | |
66 | void test_parse_map(isl_ctx *ctx, const char *str) |
67 | { |
68 | isl_map *map; |
69 | |
70 | map = isl_map_read_from_str(ctx, str); |
71 | assert(map)((void) sizeof ((map) ? 1 : 0), __extension__ ({ if (map) ; else __assert_fail ("map", "polly/lib/External/isl/isl_test.c", 71 , __extension__ __PRETTY_FUNCTION__); })); |
72 | isl_map_free(map); |
73 | } |
74 | |
75 | int test_parse_map_equal(isl_ctx *ctx, const char *str, const char *str2) |
76 | { |
77 | isl_map *map, *map2; |
78 | int equal; |
79 | |
80 | map = isl_map_read_from_str(ctx, str); |
81 | map2 = isl_map_read_from_str(ctx, str2); |
82 | equal = isl_map_is_equal(map, map2); |
83 | isl_map_free(map); |
84 | isl_map_free(map2); |
85 | |
86 | if (equal < 0) |
87 | return -1; |
88 | if (!equal) |
89 | isl_die(ctx, isl_error_unknown, "maps not equal",do { isl_handle_error(ctx, isl_error_unknown, "maps not equal" , "polly/lib/External/isl/isl_test.c", 90); return -1; } while (0) |
90 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "maps not equal" , "polly/lib/External/isl/isl_test.c", 90); return -1; } while (0); |
91 | |
92 | return 0; |
93 | } |
94 | |
95 | void test_parse_pwqp(isl_ctx *ctx, const char *str) |
96 | { |
97 | isl_pw_qpolynomial *pwqp; |
98 | |
99 | pwqp = isl_pw_qpolynomial_read_from_str(ctx, str); |
100 | assert(pwqp)((void) sizeof ((pwqp) ? 1 : 0), __extension__ ({ if (pwqp) ; else __assert_fail ("pwqp", "polly/lib/External/isl/isl_test.c" , 100, __extension__ __PRETTY_FUNCTION__); })); |
101 | isl_pw_qpolynomial_free(pwqp); |
102 | } |
103 | |
104 | static void test_parse_pwaff(isl_ctx *ctx, const char *str) |
105 | { |
106 | isl_pw_aff *pwaff; |
107 | |
108 | pwaff = isl_pw_aff_read_from_str(ctx, str); |
109 | assert(pwaff)((void) sizeof ((pwaff) ? 1 : 0), __extension__ ({ if (pwaff) ; else __assert_fail ("pwaff", "polly/lib/External/isl/isl_test.c" , 109, __extension__ __PRETTY_FUNCTION__); })); |
110 | isl_pw_aff_free(pwaff); |
111 | } |
112 | |
113 | /* Check that we can read an isl_multi_val from "str" without errors. |
114 | */ |
115 | static int test_parse_multi_val(isl_ctx *ctx, const char *str) |
116 | { |
117 | isl_multi_val *mv; |
118 | |
119 | mv = isl_multi_val_read_from_str(ctx, str); |
120 | isl_multi_val_free(mv); |
121 | |
122 | return mv ? 0 : -1; |
123 | } |
124 | |
125 | /* String descriptions of multi piecewise affine expressions |
126 | * that are used for testing printing and parsing. |
127 | */ |
128 | static const char *reparse_multi_pw_aff_tests[] = { |
129 | "{ A[x, y] -> [] : x + y >= 0 }", |
130 | "{ A[x, y] -> B[] : x + y >= 0 }", |
131 | "{ A[x, y] -> [x] : x + y >= 0 }", |
132 | "[N] -> { A[x, y] -> [x] : x + y <= N }", |
133 | "{ A[x, y] -> [x, y] : x + y >= 0 }", |
134 | "{ A[x, y] -> [(x : x >= 0), (y : y >= 0)] : x + y >= 0 }", |
135 | "[N] -> { [] : N >= 0 }", |
136 | "[N] -> { [] : N >= 0 }", |
137 | "[N] -> { [N] : N >= 0 }", |
138 | "[N] -> { [N, N + 1] : N >= 0 }", |
139 | "[N, M] -> { [(N : N >= 0), (M : M >= 0)] : N + M >= 0 }", |
140 | "{ [a] -> [b = a] }", |
141 | "{ [a] -> [b = a] : a >= 0 }", |
142 | }; |
143 | |
144 | #undef BASEunion_pw_qpolynomial |
145 | #define BASEunion_pw_qpolynomial multi_pw_aff |
146 | |
147 | #include "check_reparse_templ.c" |
148 | #include "check_reparse_test_templ.c" |
149 | |
150 | /* String descriptions that cannot be parsed |
151 | * as multi piecewise affine expressions. |
152 | */ |
153 | static const char *parse_multi_pw_aff_fail_tests[] = { |
154 | "{ [a] -> [b] : b = a }", |
155 | "{ [a] -> [b = a] : b >= 0 }", |
156 | }; |
157 | |
158 | #include "check_parse_fail_test_templ.c" |
159 | |
160 | /* String descriptions of piecewise multi affine expressions |
161 | * that are used for testing printing and parsing. |
162 | */ |
163 | static const char *reparse_pw_multi_aff_tests[] = { |
164 | "{ [x] -> [x] }", |
165 | "{ [x] -> [x % 4] }", |
166 | "{ [x] -> [x % 4] : x mod 3 = 1 }", |
167 | "{ [x, x] -> [x % 4] }", |
168 | "{ [x, x + 1] -> [x % 4] : x mod 3 = 1 }", |
169 | "{ [x, x mod 2] -> [x % 4] }", |
170 | "{ [a] -> [a//2] : exists (e0: 8*floor((-a + e0)/8) <= -8 - a + 8e0) }", |
171 | }; |
172 | |
173 | #undef BASEunion_pw_qpolynomial |
174 | #define BASEunion_pw_qpolynomial pw_multi_aff |
175 | |
176 | #include "check_reparse_templ.c" |
177 | #include "check_reparse_test_templ.c" |
178 | |
179 | /* Test parsing of piecewise multi affine expressions by printing |
180 | * the expressions and checking that parsing the output results |
181 | * in the same expression. |
182 | * Do this for an expression converted from a map with an output |
183 | * dimension name that is equal to an automatically generated name, and |
184 | * a set of expressions parsed from strings. |
185 | */ |
186 | static isl_stat test_parse_pma(isl_ctx *ctx) |
187 | { |
188 | isl_map *map; |
189 | isl_pw_multi_aff *pma; |
190 | |
191 | map = isl_map_read_from_str(ctx, "{ [a, a] -> [i1 = a + 1] }"); |
192 | pma = isl_pw_multi_aff_from_map(map); |
193 | if (check_reparse_pw_multi_aff(ctx, pma) < 0) |
194 | return isl_stat_error; |
195 | |
196 | if (check_reparse_pw_multi_aff_tests(ctx) < 0) |
197 | return isl_stat_error; |
198 | |
199 | return isl_stat_ok; |
200 | } |
201 | |
202 | /* String descriptions that cannot be parsed |
203 | * as union piecewise multi affine expressions. |
204 | */ |
205 | static const char *parse_union_pw_multi_aff_fail_tests[] = { |
206 | "{ [a] -> [b] : b = a }", |
207 | "{ [a] -> [b = a] : b >= 0 }", |
208 | }; |
209 | |
210 | #undef BASEunion_pw_qpolynomial |
211 | #define BASEunion_pw_qpolynomial union_pw_multi_aff |
212 | |
213 | #include "check_parse_fail_test_templ.c" |
214 | |
215 | /* Test parsing of union piecewise multi affine expressions. |
216 | * |
217 | * In particular, check some cases where parsing is supposed to fail. |
218 | */ |
219 | static isl_stat test_parse_upma(isl_ctx *ctx) |
220 | { |
221 | if (check_parse_union_pw_multi_aff_fail_tests(ctx) < 0) |
222 | return isl_stat_error; |
223 | |
224 | return isl_stat_ok; |
225 | } |
226 | |
227 | /* Test parsing of multi piecewise affine expressions by printing |
228 | * the expressions and checking that parsing the output results |
229 | * in the same expression. |
230 | * Do this for a couple of manually constructed expressions, |
231 | * an expression converted from a map with an output dimension name |
232 | * that is equal to an automatically generated name, and |
233 | * a set of expressions parsed from strings. |
234 | * |
235 | * Additionally, check some cases where parsing is supposed to fail. |
236 | */ |
237 | static int test_parse_mpa(isl_ctx *ctx) |
238 | { |
239 | isl_space *space; |
240 | isl_setisl_map *dom; |
241 | isl_map *map; |
242 | isl_pw_multi_aff *pma; |
243 | isl_multi_pw_aff *mpa; |
244 | isl_stat r; |
245 | |
246 | space = isl_space_set_alloc(ctx, 0, 0); |
247 | space = isl_space_set_tuple_name(space, isl_dim_set, "A"); |
248 | mpa = isl_multi_pw_aff_zero(space); |
249 | r = check_reparse_multi_pw_aff(ctx, mpa); |
250 | if (r < 0) |
251 | return -1; |
252 | |
253 | space = isl_space_set_alloc(ctx, 1, 0); |
254 | space = isl_space_set_dim_name(space, isl_dim_param, 0, "N"); |
255 | space = isl_space_set_tuple_name(space, isl_dim_set, "A"); |
256 | dom = isl_set_universe(isl_space_params(isl_space_copy(space))); |
257 | dom = isl_set_lower_bound_si(dom, isl_dim_param, 0, 5); |
258 | mpa = isl_multi_pw_aff_zero(space); |
259 | mpa = isl_multi_pw_aff_intersect_domain(mpa, dom); |
260 | r = check_reparse_multi_pw_aff(ctx, mpa); |
261 | if (r < 0) |
262 | return -1; |
263 | |
264 | map = isl_map_read_from_str(ctx, "{ [a, a] -> [i1 = a + 1] }"); |
265 | pma = isl_pw_multi_aff_from_map(map); |
266 | mpa = isl_multi_pw_aff_from_pw_multi_aff(pma); |
267 | if (check_reparse_multi_pw_aff(ctx, mpa) < 0) |
268 | return -1; |
269 | |
270 | if (check_reparse_multi_pw_aff_tests(ctx) < 0) |
271 | return -1; |
272 | if (check_parse_multi_pw_aff_fail_tests(ctx) < 0) |
273 | return -1; |
274 | |
275 | return 0; |
276 | } |
277 | |
278 | /* String descriptions of multi union piecewise affine expressions |
279 | * that are used for testing printing and parsing. |
280 | */ |
281 | static const char *reparse_multi_union_pw_aff_tests[] = { |
282 | "[]", |
283 | "A[]", |
284 | "A[B[] -> C[]]", |
285 | "(A[] : { S[x] : x > 0; T[y] : y >= 0 })", |
286 | "(A[] : { })", |
287 | "[N] -> (A[] : { })", |
288 | "[N] -> (A[] : { : N >= 0 })", |
289 | "[N] -> (A[] : { S[x] : x > N; T[y] : y >= 0 })", |
290 | "(A[] : [N] -> { S[x] : x > N; T[y] : y >= 0 })", |
291 | "A[{ S[x] -> [x + 1]; T[x] -> [x] }]", |
292 | "(A[{ S[x] -> [x + 1]; T[x] -> [x] }] : " |
293 | "{ S[x] : x > 0; T[y] : y >= 0 })", |
294 | }; |
295 | |
296 | #undef BASEunion_pw_qpolynomial |
297 | #define BASEunion_pw_qpolynomial multi_union_pw_aff |
298 | |
299 | #include "check_reparse_templ.c" |
300 | #include "check_reparse_test_templ.c" |
301 | |
302 | /* Test parsing of multi union piecewise affine expressions by printing |
303 | * the expressions and checking that parsing the output results |
304 | * in the same expression. |
305 | * Do this for a couple of manually constructed expressions and |
306 | * a set of expressions parsed from strings. |
307 | */ |
308 | static int test_parse_mupa(isl_ctx *ctx) |
309 | { |
310 | isl_space *space; |
311 | isl_multi_union_pw_aff *mupa; |
312 | isl_setisl_map *dom; |
313 | isl_union_set *uset; |
314 | isl_stat r; |
315 | |
316 | space = isl_space_set_alloc(ctx, 0, 0); |
317 | space = isl_space_set_tuple_name(space, isl_dim_set, "A"); |
318 | mupa = isl_multi_union_pw_aff_zero(space); |
319 | r = check_reparse_multi_union_pw_aff(ctx, mupa); |
320 | if (r < 0) |
321 | return -1; |
322 | |
323 | space = isl_space_set_alloc(ctx, 1, 0); |
324 | space = isl_space_set_dim_name(space, isl_dim_param, 0, "N"); |
325 | space = isl_space_set_tuple_name(space, isl_dim_set, "A"); |
326 | dom = isl_set_universe(space); |
327 | dom = isl_set_lower_bound_si(dom, isl_dim_param, 0, 5); |
328 | uset = isl_union_set_from_set(dom); |
329 | space = isl_space_set_alloc(ctx, 1, 0); |
330 | space = isl_space_set_dim_name(space, isl_dim_param, 0, "N"); |
331 | space = isl_space_set_tuple_name(space, isl_dim_set, "B"); |
332 | mupa = isl_multi_union_pw_aff_zero(space); |
333 | mupa = isl_multi_union_pw_aff_intersect_domain(mupa, uset); |
334 | r = check_reparse_multi_union_pw_aff(ctx, mupa); |
335 | if (r < 0) |
336 | return -1; |
337 | |
338 | if (check_reparse_multi_union_pw_aff_tests(ctx) < 0) |
339 | return -1; |
340 | |
341 | return 0; |
342 | } |
343 | |
344 | /* Test parsing of multi expressions. |
345 | */ |
346 | static int test_parse_multi(isl_ctx *ctx) |
347 | { |
348 | if (test_parse_mpa(ctx) < 0) |
349 | return -1; |
350 | if (test_parse_mupa(ctx) < 0) |
351 | return -1; |
352 | |
353 | return 0; |
354 | } |
355 | |
356 | /* Pairs of binary relation representations that should represent |
357 | * the same binary relations. |
358 | */ |
359 | struct { |
360 | const char *map1; |
361 | const char *map2; |
362 | } parse_map_equal_tests[] = { |
363 | { "{ [x,y] : [([x/2]+y)/3] >= 1 }", |
364 | "{ [x, y] : 2y >= 6 - x }" }, |
365 | { "{ [x,y] : x <= min(y, 2*y+3) }", |
366 | "{ [x,y] : x <= y, 2*y + 3 }" }, |
367 | { "{ [x,y] : x >= min(y, 2*y+3) }", |
368 | "{ [x, y] : (y <= x and y >= -3) or (2y <= -3 + x and y <= -4) }" }, |
369 | { "[n] -> { [c1] : c1>=0 and c1<=floord(n-4,3) }", |
370 | "[n] -> { [c1] : c1 >= 0 and 3c1 <= -4 + n }" }, |
371 | { "{ [i,j] -> [i] : i < j; [i,j] -> [j] : j <= i }", |
372 | "{ [i,j] -> [min(i,j)] }" }, |
373 | { "{ [i,j] : i != j }", |
374 | "{ [i,j] : i < j or i > j }" }, |
375 | { "{ [i,j] : (i+1)*2 >= j }", |
376 | "{ [i, j] : j <= 2 + 2i }" }, |
377 | { "{ [i] -> [i > 0 ? 4 : 5] }", |
378 | "{ [i] -> [5] : i <= 0; [i] -> [4] : i >= 1 }" }, |
379 | { "[N=2,M] -> { [i=[(M+N)/4]] }", |
380 | "[N, M] -> { [i] : N = 2 and 4i <= 2 + M and 4i >= -1 + M }" }, |
381 | { "{ [x] : x >= 0 }", |
382 | "{ [x] : x-0 >= 0 }" }, |
383 | { "{ [i] : ((i > 10)) }", |
384 | "{ [i] : i >= 11 }" }, |
385 | { "{ [i] -> [0] }", |
386 | "{ [i] -> [0 * i] }" }, |
387 | { "{ [a] -> [b] : (not false) }", |
388 | "{ [a] -> [b] : true }" }, |
389 | { "{ [i] : i/2 <= 5 }", |
390 | "{ [i] : i <= 10 }" }, |
391 | { "{Sym=[n] [i] : i <= n }", |
392 | "[n] -> { [i] : i <= n }" }, |
393 | { "{ [*] }", |
394 | "{ [a] }" }, |
395 | { "{ [i] : 2*floor(i/2) = i }", |
396 | "{ [i] : exists a : i = 2 a }" }, |
397 | { "{ [a] -> [b] : a = 5 implies b = 5 }", |
398 | "{ [a] -> [b] : a != 5 or b = 5 }" }, |
399 | { "{ [a] -> [a - 1 : a > 0] }", |
400 | "{ [a] -> [a - 1] : a > 0 }" }, |
401 | { "{ [a] -> [a - 1 : a > 0; a : a <= 0] }", |
402 | "{ [a] -> [a - 1] : a > 0; [a] -> [a] : a <= 0 }" }, |
403 | { "{ [a] -> [(a) * 2 : a >= 0; 0 : a < 0] }", |
404 | "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" }, |
405 | { "{ [a] -> [(a * 2) : a >= 0; 0 : a < 0] }", |
406 | "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" }, |
407 | { "{ [a] -> [(a * 2 : a >= 0); 0 : a < 0] }", |
408 | "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" }, |
409 | { "{ [a] -> [(a * 2 : a >= 0; 0 : a < 0)] }", |
410 | "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" }, |
411 | { "{ [a,b] -> [i,j] : a,b << i,j }", |
412 | "{ [a,b] -> [i,j] : a < i or (a = i and b < j) }" }, |
413 | { "{ [a,b] -> [i,j] : a,b <<= i,j }", |
414 | "{ [a,b] -> [i,j] : a < i or (a = i and b <= j) }" }, |
415 | { "{ [a,b] -> [i,j] : a,b >> i,j }", |
416 | "{ [a,b] -> [i,j] : a > i or (a = i and b > j) }" }, |
417 | { "{ [a,b] -> [i,j] : a,b >>= i,j }", |
418 | "{ [a,b] -> [i,j] : a > i or (a = i and b >= j) }" }, |
419 | { "{ [n] -> [i] : exists (a, b, c: 8b <= i - 32a and " |
420 | "8b >= -7 + i - 32 a and b >= 0 and b <= 3 and " |
421 | "8c < n - 32a and i < n and c >= 0 and " |
422 | "c <= 3 and c >= -4a) }", |
423 | "{ [n] -> [i] : 0 <= i < n }" }, |
424 | { "{ [x] -> [] : exists (a, b: 0 <= a <= 1 and 0 <= b <= 3 and " |
425 | "2b <= x - 8a and 2b >= -1 + x - 8a) }", |
426 | "{ [x] -> [] : 0 <= x <= 15 }" }, |
427 | { "{ [x] -> [x] : }", |
428 | "{ [x] -> [x] }" }, |
429 | { "{ [x=4:5] -> [x + 1] }", |
430 | "{ [x] -> [x + 1] : 4 <= x <= 5 }" }, |
431 | { "{ [x=4:5] -> [x + 1 : x + 1] }", |
432 | "{ [x=4:5] -> [x + 1] }" }, |
433 | { "{ [x] -> [x - 1 : x + 1] }", |
434 | "{ [x] -> [y] : x - 1 <= y <= x + 1 }" }, |
435 | { "{ [x=4:] -> [x + 1] }", |
436 | "{ [x] -> [x + 1] : 4 <= x }" }, |
437 | { "{ [x=:5] -> [x + 1] }", |
438 | "{ [x] -> [x + 1] : x <= 5 }" }, |
439 | { "{ [x=:] -> [x + 1] }", |
440 | "{ [x] -> [x + 1] }" }, |
441 | { "{ [:] -> [:] }", |
442 | "{ [x] -> [y] }" }, |
443 | { "{ [x, x//4] }", |
444 | "{ [x, floor(x/4)] }" }, |
445 | { "{ [10//4] }", |
446 | "{ [2] }" }, |
447 | { "{ [-1//4] }", |
448 | "{ [-1] }" }, |
449 | { "{ [0-1//4] }", |
450 | "{ [0] }" }, |
451 | { "{ [- 1//4] }", |
452 | "{ [-1] }" }, |
453 | { "{ [0 - 1//4] }", |
454 | "{ [0] }" }, |
455 | { "{ [0--1//4] }", |
456 | "{ [1] }" }, |
457 | { "{ [0 - -1//4] }", |
458 | "{ [1] }" }, |
459 | { "{ [-2^2:2^2-1] }", |
460 | "{ [-4:3] }" }, |
461 | { "{ [2*-2] }", |
462 | "{ [-4] }" }, |
463 | { "{ [i,i*-2] }", |
464 | "{ [i,-2i] }" }, |
465 | { "[a, b, c, d] -> { [max(a,b,c,d)] }", |
466 | "[a, b, c, d] -> { [a] : b < a and c < a and d < a; " |
467 | "[b] : b >= a and c < b and d < b; " |
468 | "[c] : c >= a and c >= b and d < c; " |
469 | "[d] : d >= a and d >= b and d >= c }" }, |
470 | { "[a, b, c, d] -> { [min(a,b,c,d)] }", |
471 | "[a, b, c, d] -> { [a] : b >= a and c >= a and d >= a; " |
472 | "[b] : b < a and c >= b and d >= b; " |
473 | "[c] : c < b and c < a and d >= c; " |
474 | "[d] : d < c and d < b and d < a }" }, |
475 | }; |
476 | |
477 | int test_parse(struct isl_ctx *ctx) |
478 | { |
479 | int i; |
480 | isl_map *map, *map2; |
481 | const char *str, *str2; |
482 | |
483 | if (test_parse_multi_val(ctx, "{ A[B[2] -> C[5, 7]] }") < 0) |
484 | return -1; |
485 | if (test_parse_multi_val(ctx, "[n] -> { [2] }") < 0) |
486 | return -1; |
487 | if (test_parse_multi_val(ctx, "{ A[4, infty, NaN, -1/2, 2/3] }") < 0) |
488 | return -1; |
489 | if (test_parse_multi(ctx) < 0) |
490 | return -1; |
491 | if (test_parse_pma(ctx) < 0) |
492 | return -1; |
493 | if (test_parse_upma(ctx) < 0) |
494 | return -1; |
495 | |
496 | str = "{ [i] -> [-i] }"; |
497 | map = isl_map_read_from_str(ctx, str); |
498 | assert(map)((void) sizeof ((map) ? 1 : 0), __extension__ ({ if (map) ; else __assert_fail ("map", "polly/lib/External/isl/isl_test.c", 498 , __extension__ __PRETTY_FUNCTION__); })); |
499 | isl_map_free(map); |
500 | |
501 | str = "{ A[i] -> L[([i/3])] }"; |
502 | map = isl_map_read_from_str(ctx, str); |
503 | assert(map)((void) sizeof ((map) ? 1 : 0), __extension__ ({ if (map) ; else __assert_fail ("map", "polly/lib/External/isl/isl_test.c", 503 , __extension__ __PRETTY_FUNCTION__); })); |
504 | isl_map_free(map); |
505 | |
506 | test_parse_map(ctx, "{[[s] -> A[i]] -> [[s+1] -> A[i]]}"); |
507 | test_parse_map(ctx, "{ [p1, y1, y2] -> [2, y1, y2] : " |
508 | "p1 = 1 && (y1 <= y2 || y2 = 0) }"); |
509 | |
510 | for (i = 0; i < ARRAY_SIZE(parse_map_equal_tests)(sizeof(parse_map_equal_tests)/sizeof(*parse_map_equal_tests) ); ++i) { |
511 | str = parse_map_equal_tests[i].map1; |
512 | str2 = parse_map_equal_tests[i].map2; |
513 | if (test_parse_map_equal(ctx, str, str2) < 0) |
514 | return -1; |
515 | } |
516 | |
517 | str = "{[new,old] -> [new+1-2*[(new+1)/2],old+1-2*[(old+1)/2]]}"; |
518 | map = isl_map_read_from_str(ctx, str); |
519 | str = "{ [new, old] -> [o0, o1] : " |
520 | "exists (e0 = [(-1 - new + o0)/2], e1 = [(-1 - old + o1)/2]: " |
521 | "2e0 = -1 - new + o0 and 2e1 = -1 - old + o1 and o0 >= 0 and " |
522 | "o0 <= 1 and o1 >= 0 and o1 <= 1) }"; |
523 | map2 = isl_map_read_from_str(ctx, str); |
524 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 524, __extension__ __PRETTY_FUNCTION__ ); })); |
525 | isl_map_free(map); |
526 | isl_map_free(map2); |
527 | |
528 | str = "{[new,old] -> [new+1-2*[(new+1)/2],old+1-2*[(old+1)/2]]}"; |
529 | map = isl_map_read_from_str(ctx, str); |
530 | str = "{[new,old] -> [(new+1)%2,(old+1)%2]}"; |
531 | map2 = isl_map_read_from_str(ctx, str); |
532 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 532, __extension__ __PRETTY_FUNCTION__ ); })); |
533 | isl_map_free(map); |
534 | isl_map_free(map2); |
535 | |
536 | test_parse_pwqp(ctx, "{ [i] -> i + [ (i + [i/3])/2 ] }"); |
537 | test_parse_map(ctx, "{ S1[i] -> [([i/10]),i%10] : 0 <= i <= 45 }"); |
538 | test_parse_pwaff(ctx, "{ [i] -> [i + 1] : i > 0; [a] -> [a] : a < 0 }"); |
539 | test_parse_pwqp(ctx, "{ [x] -> ([(x)/2] * [(x)/3]) }"); |
540 | test_parse_pwaff(ctx, "{ [] -> [(100)] }"); |
541 | |
542 | return 0; |
543 | } |
544 | |
545 | static int test_read(isl_ctx *ctx) |
546 | { |
547 | char *filename; |
548 | FILE *input; |
549 | isl_basic_setisl_basic_map *bset1, *bset2; |
550 | const char *str = "{[y]: Exists ( alpha : 2alpha = y)}"; |
551 | int equal; |
552 | |
553 | filename = get_filename(ctx, "set", "omega"); |
554 | assert(filename)((void) sizeof ((filename) ? 1 : 0), __extension__ ({ if (filename ) ; else __assert_fail ("filename", "polly/lib/External/isl/isl_test.c" , 554, __extension__ __PRETTY_FUNCTION__); })); |
555 | input = fopen(filename, "r"); |
556 | assert(input)((void) sizeof ((input) ? 1 : 0), __extension__ ({ if (input) ; else __assert_fail ("input", "polly/lib/External/isl/isl_test.c" , 556, __extension__ __PRETTY_FUNCTION__); })); |
557 | |
558 | bset1 = isl_basic_set_read_from_file(ctx, input); |
559 | bset2 = isl_basic_set_read_from_str(ctx, str); |
560 | |
561 | equal = isl_basic_set_is_equal(bset1, bset2); |
562 | |
563 | isl_basic_set_free(bset1); |
564 | isl_basic_set_free(bset2); |
565 | free(filename); |
566 | |
567 | fclose(input); |
568 | |
569 | if (equal < 0) |
570 | return -1; |
571 | if (!equal) |
572 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "read sets not equal" , "polly/lib/External/isl/isl_test.c", 573); return -1; } while (0) |
573 | "read sets not equal", return -1)do { isl_handle_error(ctx, isl_error_unknown, "read sets not equal" , "polly/lib/External/isl/isl_test.c", 573); return -1; } while (0); |
574 | |
575 | return 0; |
576 | } |
577 | |
578 | static int test_bounded(isl_ctx *ctx) |
579 | { |
580 | isl_setisl_map *set; |
581 | isl_bool bounded; |
582 | |
583 | set = isl_set_read_from_str(ctx, "[n] -> {[i] : 0 <= i <= n }"); |
584 | bounded = isl_set_is_bounded(set); |
585 | isl_set_free(set); |
586 | |
587 | if (bounded < 0) |
588 | return -1; |
589 | if (!bounded) |
590 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "set not considered bounded" , "polly/lib/External/isl/isl_test.c", 591); return -1; } while (0) |
591 | "set not considered bounded", return -1)do { isl_handle_error(ctx, isl_error_unknown, "set not considered bounded" , "polly/lib/External/isl/isl_test.c", 591); return -1; } while (0); |
592 | |
593 | set = isl_set_read_from_str(ctx, "{[n, i] : 0 <= i <= n }"); |
594 | bounded = isl_set_is_bounded(set); |
595 | assert(!bounded)((void) sizeof ((!bounded) ? 1 : 0), __extension__ ({ if (!bounded ) ; else __assert_fail ("!bounded", "polly/lib/External/isl/isl_test.c" , 595, __extension__ __PRETTY_FUNCTION__); })); |
596 | isl_set_free(set); |
597 | |
598 | if (bounded < 0) |
599 | return -1; |
600 | if (bounded) |
601 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "set considered bounded" , "polly/lib/External/isl/isl_test.c", 602); return -1; } while (0) |
602 | "set considered bounded", return -1)do { isl_handle_error(ctx, isl_error_unknown, "set considered bounded" , "polly/lib/External/isl/isl_test.c", 602); return -1; } while (0); |
603 | |
604 | set = isl_set_read_from_str(ctx, "[n] -> {[i] : i <= n }"); |
605 | bounded = isl_set_is_bounded(set); |
606 | isl_set_free(set); |
607 | |
608 | if (bounded < 0) |
609 | return -1; |
610 | if (bounded) |
611 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "set considered bounded" , "polly/lib/External/isl/isl_test.c", 612); return -1; } while (0) |
612 | "set considered bounded", return -1)do { isl_handle_error(ctx, isl_error_unknown, "set considered bounded" , "polly/lib/External/isl/isl_test.c", 612); return -1; } while (0); |
613 | |
614 | return 0; |
615 | } |
616 | |
617 | /* Construct the basic set { [i] : 5 <= i <= N } */ |
618 | static int test_construction_1(isl_ctx *ctx) |
619 | { |
620 | isl_space *space; |
621 | isl_local_space *ls; |
622 | isl_basic_setisl_basic_map *bset; |
623 | isl_constraint *c; |
624 | |
625 | space = isl_space_set_alloc(ctx, 1, 1); |
626 | bset = isl_basic_set_universe(isl_space_copy(space)); |
627 | ls = isl_local_space_from_space(space); |
628 | |
629 | c = isl_constraint_alloc_inequality(isl_local_space_copy(ls)); |
630 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
631 | c = isl_constraint_set_coefficient_si(c, isl_dim_param, 0, 1); |
632 | bset = isl_basic_set_add_constraint(bset, c); |
633 | |
634 | c = isl_constraint_alloc_inequality(isl_local_space_copy(ls)); |
635 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1); |
636 | c = isl_constraint_set_constant_si(c, -5); |
637 | bset = isl_basic_set_add_constraint(bset, c); |
638 | |
639 | isl_local_space_free(ls); |
640 | isl_basic_set_free(bset); |
641 | |
642 | return 0; |
643 | } |
644 | |
645 | /* Construct the basic set { [x] : -100 <= x <= 100 } |
646 | * using isl_basic_set_{lower,upper}_bound_val and |
647 | * check that it is equal the same basic set parsed from a string. |
648 | */ |
649 | static int test_construction_2(isl_ctx *ctx) |
650 | { |
651 | isl_bool equal; |
652 | isl_val *v; |
653 | isl_space *space; |
654 | isl_basic_setisl_basic_map *bset1, *bset2; |
655 | |
656 | v = isl_val_int_from_si(ctx, 100); |
657 | space = isl_space_set_alloc(ctx, 0, 1); |
658 | bset1 = isl_basic_set_universe(space); |
659 | bset1 = isl_basic_set_upper_bound_val(bset1, isl_dim_set, 0, |
660 | isl_val_copy(v)); |
661 | bset1 = isl_basic_set_lower_bound_val(bset1, isl_dim_set, 0, |
662 | isl_val_neg(v)); |
663 | bset2 = isl_basic_set_read_from_str(ctx, "{ [x] : -100 <= x <= 100 }"); |
664 | equal = isl_basic_set_is_equal(bset1, bset2); |
665 | isl_basic_set_free(bset1); |
666 | isl_basic_set_free(bset2); |
667 | |
668 | if (equal < 0) |
669 | return -1; |
670 | if (!equal) |
671 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "failed construction" , "polly/lib/External/isl/isl_test.c", 672); return -1; } while (0) |
672 | "failed construction", return -1)do { isl_handle_error(ctx, isl_error_unknown, "failed construction" , "polly/lib/External/isl/isl_test.c", 672); return -1; } while (0); |
673 | |
674 | return 0; |
675 | } |
676 | |
677 | /* Basic tests for constructing basic sets. |
678 | */ |
679 | static int test_construction(isl_ctx *ctx) |
680 | { |
681 | if (test_construction_1(ctx) < 0) |
682 | return -1; |
683 | if (test_construction_2(ctx) < 0) |
684 | return -1; |
685 | return 0; |
686 | } |
687 | |
688 | static int test_dim(isl_ctx *ctx) |
689 | { |
690 | const char *str; |
691 | isl_map *map1, *map2; |
692 | int equal; |
693 | |
694 | map1 = isl_map_read_from_str(ctx, |
695 | "[n] -> { [i] -> [j] : exists (a = [i/10] : i - 10a <= n ) }"); |
696 | map1 = isl_map_add_dims(map1, isl_dim_in, 1); |
697 | map2 = isl_map_read_from_str(ctx, |
698 | "[n] -> { [i,k] -> [j] : exists (a = [i/10] : i - 10a <= n ) }"); |
699 | equal = isl_map_is_equal(map1, map2); |
700 | isl_map_free(map2); |
701 | |
702 | map1 = isl_map_project_out(map1, isl_dim_in, 0, 1); |
703 | map2 = isl_map_read_from_str(ctx, "[n] -> { [i] -> [j] : n >= 0 }"); |
704 | if (equal >= 0 && equal) |
705 | equal = isl_map_is_equal(map1, map2); |
706 | |
707 | isl_map_free(map1); |
708 | isl_map_free(map2); |
709 | |
710 | if (equal < 0) |
711 | return -1; |
712 | if (!equal) |
713 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 714); return -1; } while (0) |
714 | "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 714); return -1; } while (0); |
715 | |
716 | str = "[n] -> { [i] -> [] : exists a : 0 <= i <= n and i = 2 a }"; |
717 | map1 = isl_map_read_from_str(ctx, str); |
718 | str = "{ [i] -> [j] : exists a : 0 <= i <= j and i = 2 a }"; |
719 | map2 = isl_map_read_from_str(ctx, str); |
720 | map1 = isl_map_move_dims(map1, isl_dim_out, 0, isl_dim_param, 0, 1); |
721 | equal = isl_map_is_equal(map1, map2); |
722 | isl_map_free(map1); |
723 | isl_map_free(map2); |
724 | |
725 | if (equal < 0) |
726 | return -1; |
727 | if (!equal) |
728 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 729); return -1; } while (0) |
729 | "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 729); return -1; } while (0); |
730 | |
731 | return 0; |
732 | } |
733 | |
734 | #undef BASEunion_pw_qpolynomial |
735 | #define BASEunion_pw_qpolynomial multi_val |
736 | #include "isl_test_plain_equal_templ.c" |
737 | |
738 | #undef BASEunion_pw_qpolynomial |
739 | #define BASEunion_pw_qpolynomial multi_aff |
740 | #include "isl_test_plain_equal_templ.c" |
741 | |
742 | /* Check that "val" is equal to the value described by "str". |
743 | * If "str" is "NaN", then check for a NaN value explicitly. |
744 | */ |
745 | static isl_stat val_check_equal(__isl_keep isl_val *val, const char *str) |
746 | { |
747 | isl_bool ok, is_nan; |
748 | isl_ctx *ctx; |
749 | isl_val *res; |
750 | |
751 | if (!val) |
752 | return isl_stat_error; |
753 | |
754 | ctx = isl_val_get_ctx(val); |
755 | res = isl_val_read_from_str(ctx, str); |
756 | is_nan = isl_val_is_nan(res); |
757 | if (is_nan < 0) |
758 | ok = isl_bool_error; |
759 | else if (is_nan) |
760 | ok = isl_val_is_nan(val); |
761 | else |
762 | ok = isl_val_eq(val, res); |
763 | isl_val_free(res); |
764 | if (ok < 0) |
765 | return isl_stat_error; |
766 | if (!ok) |
767 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 768); return isl_stat_error ; } while (0) |
768 | "unexpected result", return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 768); return isl_stat_error ; } while (0); |
769 | return isl_stat_ok; |
770 | } |
771 | |
772 | struct { |
773 | __isl_give isl_val *(*op)(__isl_take isl_val *v); |
774 | const char *arg; |
775 | const char *res; |
776 | } val_un_tests[] = { |
777 | { &isl_val_neg, "0", "0" }, |
778 | { &isl_val_abs, "0", "0" }, |
779 | { &isl_val_pow2, "0", "1" }, |
780 | { &isl_val_floor, "0", "0" }, |
781 | { &isl_val_ceil, "0", "0" }, |
782 | { &isl_val_neg, "1", "-1" }, |
783 | { &isl_val_neg, "-1", "1" }, |
784 | { &isl_val_neg, "1/2", "-1/2" }, |
785 | { &isl_val_neg, "-1/2", "1/2" }, |
786 | { &isl_val_neg, "infty", "-infty" }, |
787 | { &isl_val_neg, "-infty", "infty" }, |
788 | { &isl_val_neg, "NaN", "NaN" }, |
789 | { &isl_val_abs, "1", "1" }, |
790 | { &isl_val_abs, "-1", "1" }, |
791 | { &isl_val_abs, "1/2", "1/2" }, |
792 | { &isl_val_abs, "-1/2", "1/2" }, |
793 | { &isl_val_abs, "infty", "infty" }, |
794 | { &isl_val_abs, "-infty", "infty" }, |
795 | { &isl_val_abs, "NaN", "NaN" }, |
796 | { &isl_val_floor, "1", "1" }, |
797 | { &isl_val_floor, "-1", "-1" }, |
798 | { &isl_val_floor, "1/2", "0" }, |
799 | { &isl_val_floor, "-1/2", "-1" }, |
800 | { &isl_val_floor, "infty", "infty" }, |
801 | { &isl_val_floor, "-infty", "-infty" }, |
802 | { &isl_val_floor, "NaN", "NaN" }, |
803 | { &isl_val_ceil, "1", "1" }, |
804 | { &isl_val_ceil, "-1", "-1" }, |
805 | { &isl_val_ceil, "1/2", "1" }, |
806 | { &isl_val_ceil, "-1/2", "0" }, |
807 | { &isl_val_ceil, "infty", "infty" }, |
808 | { &isl_val_ceil, "-infty", "-infty" }, |
809 | { &isl_val_ceil, "NaN", "NaN" }, |
810 | { &isl_val_pow2, "-3", "1/8" }, |
811 | { &isl_val_pow2, "-1", "1/2" }, |
812 | { &isl_val_pow2, "1", "2" }, |
813 | { &isl_val_pow2, "2", "4" }, |
814 | { &isl_val_pow2, "3", "8" }, |
815 | { &isl_val_inv, "1", "1" }, |
816 | { &isl_val_inv, "2", "1/2" }, |
817 | { &isl_val_inv, "1/2", "2" }, |
818 | { &isl_val_inv, "-2", "-1/2" }, |
819 | { &isl_val_inv, "-1/2", "-2" }, |
820 | { &isl_val_inv, "0", "NaN" }, |
821 | { &isl_val_inv, "NaN", "NaN" }, |
822 | { &isl_val_inv, "infty", "0" }, |
823 | { &isl_val_inv, "-infty", "0" }, |
824 | }; |
825 | |
826 | /* Perform some basic tests of unary operations on isl_val objects. |
827 | */ |
828 | static int test_un_val(isl_ctx *ctx) |
829 | { |
830 | int i; |
831 | isl_val *v; |
832 | __isl_give isl_val *(*fn)(__isl_take isl_val *v); |
833 | |
834 | for (i = 0; i < ARRAY_SIZE(val_un_tests)(sizeof(val_un_tests)/sizeof(*val_un_tests)); ++i) { |
835 | isl_stat r; |
836 | |
837 | v = isl_val_read_from_str(ctx, val_un_tests[i].arg); |
838 | fn = val_un_tests[i].op; |
839 | v = fn(v); |
840 | r = val_check_equal(v, val_un_tests[i].res); |
841 | isl_val_free(v); |
842 | if (r < 0) |
843 | return -1; |
844 | } |
845 | |
846 | return 0; |
847 | } |
848 | |
849 | struct { |
850 | __isl_give isl_val *(*fn)(__isl_take isl_val *v1, |
851 | __isl_take isl_val *v2); |
852 | } val_bin_op[] = { |
853 | ['+'] = { &isl_val_add }, |
854 | ['-'] = { &isl_val_sub }, |
855 | ['*'] = { &isl_val_mul }, |
856 | ['/'] = { &isl_val_div }, |
857 | ['g'] = { &isl_val_gcd }, |
858 | ['m'] = { &isl_val_min }, |
859 | ['M'] = { &isl_val_max }, |
860 | }; |
861 | |
862 | struct { |
863 | const char *arg1; |
864 | unsigned char op; |
865 | const char *arg2; |
866 | const char *res; |
867 | } val_bin_tests[] = { |
868 | { "0", '+', "0", "0" }, |
869 | { "1", '+', "0", "1" }, |
870 | { "1", '+', "1", "2" }, |
871 | { "1", '-', "1", "0" }, |
872 | { "1", '*', "1", "1" }, |
873 | { "1", '/', "1", "1" }, |
874 | { "2", '*', "3", "6" }, |
875 | { "2", '*', "1/2", "1" }, |
876 | { "2", '*', "1/3", "2/3" }, |
877 | { "2/3", '*', "3/5", "2/5" }, |
878 | { "2/3", '*', "7/5", "14/15" }, |
879 | { "2", '/', "1/2", "4" }, |
880 | { "-2", '/', "-1/2", "4" }, |
881 | { "-2", '/', "1/2", "-4" }, |
882 | { "2", '/', "-1/2", "-4" }, |
883 | { "2", '/', "2", "1" }, |
884 | { "2", '/', "3", "2/3" }, |
885 | { "2/3", '/', "5/3", "2/5" }, |
886 | { "2/3", '/', "5/7", "14/15" }, |
887 | { "0", '/', "0", "NaN" }, |
888 | { "42", '/', "0", "NaN" }, |
889 | { "-42", '/', "0", "NaN" }, |
890 | { "infty", '/', "0", "NaN" }, |
891 | { "-infty", '/', "0", "NaN" }, |
892 | { "NaN", '/', "0", "NaN" }, |
893 | { "0", '/', "NaN", "NaN" }, |
894 | { "42", '/', "NaN", "NaN" }, |
895 | { "-42", '/', "NaN", "NaN" }, |
896 | { "infty", '/', "NaN", "NaN" }, |
897 | { "-infty", '/', "NaN", "NaN" }, |
898 | { "NaN", '/', "NaN", "NaN" }, |
899 | { "0", '/', "infty", "0" }, |
900 | { "42", '/', "infty", "0" }, |
901 | { "-42", '/', "infty", "0" }, |
902 | { "infty", '/', "infty", "NaN" }, |
903 | { "-infty", '/', "infty", "NaN" }, |
904 | { "NaN", '/', "infty", "NaN" }, |
905 | { "0", '/', "-infty", "0" }, |
906 | { "42", '/', "-infty", "0" }, |
907 | { "-42", '/', "-infty", "0" }, |
908 | { "infty", '/', "-infty", "NaN" }, |
909 | { "-infty", '/', "-infty", "NaN" }, |
910 | { "NaN", '/', "-infty", "NaN" }, |
911 | { "1", '-', "1/3", "2/3" }, |
912 | { "1/3", '+', "1/2", "5/6" }, |
913 | { "1/2", '+', "1/2", "1" }, |
914 | { "3/4", '-', "1/4", "1/2" }, |
915 | { "1/2", '-', "1/3", "1/6" }, |
916 | { "infty", '+', "42", "infty" }, |
917 | { "infty", '+', "infty", "infty" }, |
918 | { "42", '+', "infty", "infty" }, |
919 | { "infty", '-', "infty", "NaN" }, |
920 | { "infty", '*', "infty", "infty" }, |
921 | { "infty", '*', "-infty", "-infty" }, |
922 | { "-infty", '*', "infty", "-infty" }, |
923 | { "-infty", '*', "-infty", "infty" }, |
924 | { "0", '*', "infty", "NaN" }, |
925 | { "1", '*', "infty", "infty" }, |
926 | { "infty", '*', "0", "NaN" }, |
927 | { "infty", '*', "42", "infty" }, |
928 | { "42", '-', "infty", "-infty" }, |
929 | { "infty", '+', "-infty", "NaN" }, |
930 | { "4", 'g', "6", "2" }, |
931 | { "5", 'g', "6", "1" }, |
932 | { "42", 'm', "3", "3" }, |
933 | { "42", 'M', "3", "42" }, |
934 | { "3", 'm', "42", "3" }, |
935 | { "3", 'M', "42", "42" }, |
936 | { "42", 'm', "infty", "42" }, |
937 | { "42", 'M', "infty", "infty" }, |
938 | { "42", 'm', "-infty", "-infty" }, |
939 | { "42", 'M', "-infty", "42" }, |
940 | { "42", 'm', "NaN", "NaN" }, |
941 | { "42", 'M', "NaN", "NaN" }, |
942 | { "infty", 'm', "-infty", "-infty" }, |
943 | { "infty", 'M', "-infty", "infty" }, |
944 | }; |
945 | |
946 | /* Perform some basic tests of binary operations on isl_val objects. |
947 | */ |
948 | static int test_bin_val(isl_ctx *ctx) |
949 | { |
950 | int i; |
951 | isl_val *v1, *v2, *res; |
952 | __isl_give isl_val *(*fn)(__isl_take isl_val *v1, |
953 | __isl_take isl_val *v2); |
954 | int ok; |
955 | |
956 | for (i = 0; i < ARRAY_SIZE(val_bin_tests)(sizeof(val_bin_tests)/sizeof(*val_bin_tests)); ++i) { |
957 | v1 = isl_val_read_from_str(ctx, val_bin_tests[i].arg1); |
958 | v2 = isl_val_read_from_str(ctx, val_bin_tests[i].arg2); |
959 | res = isl_val_read_from_str(ctx, val_bin_tests[i].res); |
960 | fn = val_bin_op[val_bin_tests[i].op].fn; |
961 | v1 = fn(v1, v2); |
962 | if (isl_val_is_nan(res)) |
963 | ok = isl_val_is_nan(v1); |
964 | else |
965 | ok = isl_val_eq(v1, res); |
966 | isl_val_free(v1); |
967 | isl_val_free(res); |
968 | if (ok < 0) |
969 | return -1; |
970 | if (!ok) |
971 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 972); return -1; } while (0) |
972 | "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 972); return -1; } while (0); |
973 | } |
974 | |
975 | return 0; |
976 | } |
977 | |
978 | /* Perform some basic tests on isl_val objects. |
979 | */ |
980 | static int test_val(isl_ctx *ctx) |
981 | { |
982 | if (test_un_val(ctx) < 0) |
983 | return -1; |
984 | if (test_bin_val(ctx) < 0) |
985 | return -1; |
986 | return 0; |
987 | } |
988 | |
989 | /* Sets described using existentially quantified variables that |
990 | * can also be described without. |
991 | */ |
992 | static const char *elimination_tests[] = { |
993 | "{ [i,j] : 2 * [i/2] + 3 * [j/4] <= 10 and 2 i = j }", |
994 | "{ [m, w] : exists a : w - 2m - 5 <= 3a <= m - 2w }", |
995 | "{ [m, w] : exists a : w >= 0 and a < m and -1 + w <= a <= 2m - w }", |
996 | }; |
997 | |
998 | /* Check that redundant existentially quantified variables are |
999 | * getting removed. |
1000 | */ |
1001 | static int test_elimination(isl_ctx *ctx) |
1002 | { |
1003 | int i; |
1004 | isl_size n; |
1005 | isl_basic_setisl_basic_map *bset; |
1006 | |
1007 | for (i = 0; i < ARRAY_SIZE(elimination_tests)(sizeof(elimination_tests)/sizeof(*elimination_tests)); ++i) { |
1008 | bset = isl_basic_set_read_from_str(ctx, elimination_tests[i]); |
1009 | n = isl_basic_set_dim(bset, isl_dim_div); |
1010 | isl_basic_set_free(bset); |
1011 | if (n < 0) |
1012 | return -1; |
1013 | if (n != 0) |
1014 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "expecting no existentials" , "polly/lib/External/isl/isl_test.c", 1015); return -1; } while (0) |
1015 | "expecting no existentials", return -1)do { isl_handle_error(ctx, isl_error_unknown, "expecting no existentials" , "polly/lib/External/isl/isl_test.c", 1015); return -1; } while (0); |
1016 | } |
1017 | |
1018 | return 0; |
1019 | } |
1020 | |
1021 | static int test_div(isl_ctx *ctx) |
1022 | { |
1023 | const char *str; |
1024 | int empty; |
1025 | isl_space *space; |
1026 | isl_setisl_map *set; |
1027 | isl_local_space *ls; |
1028 | struct isl_basic_setisl_basic_map *bset; |
1029 | struct isl_constraint *c; |
1030 | |
1031 | /* test 1 */ |
1032 | space = isl_space_set_alloc(ctx, 0, 3); |
1033 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1034 | ls = isl_local_space_from_space(space); |
1035 | |
1036 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1037 | c = isl_constraint_set_constant_si(c, -1); |
1038 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1); |
1039 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3); |
1040 | bset = isl_basic_set_add_constraint(bset, c); |
1041 | |
1042 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1043 | c = isl_constraint_set_constant_si(c, 1); |
1044 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1045 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 3); |
1046 | bset = isl_basic_set_add_constraint(bset, c); |
1047 | |
1048 | bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2); |
1049 | |
1050 | assert(bset && bset->n_div == 1)((void) sizeof ((bset && bset->n_div == 1) ? 1 : 0 ), __extension__ ({ if (bset && bset->n_div == 1) ; else __assert_fail ("bset && bset->n_div == 1", "polly/lib/External/isl/isl_test.c" , 1050, __extension__ __PRETTY_FUNCTION__); })); |
1051 | isl_local_space_free(ls); |
1052 | isl_basic_set_free(bset); |
1053 | |
1054 | /* test 2 */ |
1055 | space = isl_space_set_alloc(ctx, 0, 3); |
1056 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1057 | ls = isl_local_space_from_space(space); |
1058 | |
1059 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1060 | c = isl_constraint_set_constant_si(c, 1); |
1061 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1062 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3); |
1063 | bset = isl_basic_set_add_constraint(bset, c); |
1064 | |
1065 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1066 | c = isl_constraint_set_constant_si(c, -1); |
1067 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1); |
1068 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 3); |
1069 | bset = isl_basic_set_add_constraint(bset, c); |
1070 | |
1071 | bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2); |
1072 | |
1073 | assert(bset && bset->n_div == 1)((void) sizeof ((bset && bset->n_div == 1) ? 1 : 0 ), __extension__ ({ if (bset && bset->n_div == 1) ; else __assert_fail ("bset && bset->n_div == 1", "polly/lib/External/isl/isl_test.c" , 1073, __extension__ __PRETTY_FUNCTION__); })); |
1074 | isl_local_space_free(ls); |
1075 | isl_basic_set_free(bset); |
1076 | |
1077 | /* test 3 */ |
1078 | space = isl_space_set_alloc(ctx, 0, 3); |
1079 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1080 | ls = isl_local_space_from_space(space); |
1081 | |
1082 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1083 | c = isl_constraint_set_constant_si(c, 1); |
1084 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1085 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3); |
1086 | bset = isl_basic_set_add_constraint(bset, c); |
1087 | |
1088 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1089 | c = isl_constraint_set_constant_si(c, -3); |
1090 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1); |
1091 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 4); |
1092 | bset = isl_basic_set_add_constraint(bset, c); |
1093 | |
1094 | bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2); |
1095 | |
1096 | assert(bset && bset->n_div == 1)((void) sizeof ((bset && bset->n_div == 1) ? 1 : 0 ), __extension__ ({ if (bset && bset->n_div == 1) ; else __assert_fail ("bset && bset->n_div == 1", "polly/lib/External/isl/isl_test.c" , 1096, __extension__ __PRETTY_FUNCTION__); })); |
1097 | isl_local_space_free(ls); |
1098 | isl_basic_set_free(bset); |
1099 | |
1100 | /* test 4 */ |
1101 | space = isl_space_set_alloc(ctx, 0, 3); |
1102 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1103 | ls = isl_local_space_from_space(space); |
1104 | |
1105 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1106 | c = isl_constraint_set_constant_si(c, 2); |
1107 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1108 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3); |
1109 | bset = isl_basic_set_add_constraint(bset, c); |
1110 | |
1111 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1112 | c = isl_constraint_set_constant_si(c, -1); |
1113 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1); |
1114 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 6); |
1115 | bset = isl_basic_set_add_constraint(bset, c); |
1116 | |
1117 | bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2); |
1118 | |
1119 | assert(isl_basic_set_is_empty(bset))((void) sizeof ((isl_basic_set_is_empty(bset)) ? 1 : 0), __extension__ ({ if (isl_basic_set_is_empty(bset)) ; else __assert_fail ("isl_basic_set_is_empty(bset)" , "polly/lib/External/isl/isl_test.c", 1119, __extension__ __PRETTY_FUNCTION__ ); })); |
1120 | isl_local_space_free(ls); |
1121 | isl_basic_set_free(bset); |
1122 | |
1123 | /* test 5 */ |
1124 | space = isl_space_set_alloc(ctx, 0, 3); |
1125 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1126 | ls = isl_local_space_from_space(space); |
1127 | |
1128 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1129 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1130 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 3); |
1131 | bset = isl_basic_set_add_constraint(bset, c); |
1132 | |
1133 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1134 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1); |
1135 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3); |
1136 | bset = isl_basic_set_add_constraint(bset, c); |
1137 | |
1138 | bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 1); |
1139 | |
1140 | assert(bset && bset->n_div == 0)((void) sizeof ((bset && bset->n_div == 0) ? 1 : 0 ), __extension__ ({ if (bset && bset->n_div == 0) ; else __assert_fail ("bset && bset->n_div == 0", "polly/lib/External/isl/isl_test.c" , 1140, __extension__ __PRETTY_FUNCTION__); })); |
1141 | isl_basic_set_free(bset); |
1142 | isl_local_space_free(ls); |
1143 | |
1144 | /* test 6 */ |
1145 | space = isl_space_set_alloc(ctx, 0, 3); |
1146 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1147 | ls = isl_local_space_from_space(space); |
1148 | |
1149 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1150 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1151 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 6); |
1152 | bset = isl_basic_set_add_constraint(bset, c); |
1153 | |
1154 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1155 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1); |
1156 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3); |
1157 | bset = isl_basic_set_add_constraint(bset, c); |
1158 | |
1159 | bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 1); |
1160 | |
1161 | assert(bset && bset->n_div == 1)((void) sizeof ((bset && bset->n_div == 1) ? 1 : 0 ), __extension__ ({ if (bset && bset->n_div == 1) ; else __assert_fail ("bset && bset->n_div == 1", "polly/lib/External/isl/isl_test.c" , 1161, __extension__ __PRETTY_FUNCTION__); })); |
1162 | isl_basic_set_free(bset); |
1163 | isl_local_space_free(ls); |
1164 | |
1165 | /* test 7 */ |
1166 | /* This test is a bit tricky. We set up an equality |
1167 | * a + 3b + 3c = 6 e0 |
1168 | * Normalization of divs creates _two_ divs |
1169 | * a = 3 e0 |
1170 | * c - b - e0 = 2 e1 |
1171 | * Afterwards e0 is removed again because it has coefficient -1 |
1172 | * and we end up with the original equality and div again. |
1173 | * Perhaps we can avoid the introduction of this temporary div. |
1174 | */ |
1175 | space = isl_space_set_alloc(ctx, 0, 4); |
1176 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1177 | ls = isl_local_space_from_space(space); |
1178 | |
1179 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1180 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1181 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3); |
1182 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, -3); |
1183 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 3, 6); |
1184 | bset = isl_basic_set_add_constraint(bset, c); |
1185 | |
1186 | bset = isl_basic_set_project_out(bset, isl_dim_set, 3, 1); |
1187 | |
1188 | /* Test disabled for now */ |
1189 | /* |
1190 | assert(bset && bset->n_div == 1); |
1191 | */ |
1192 | isl_local_space_free(ls); |
1193 | isl_basic_set_free(bset); |
1194 | |
1195 | /* test 8 */ |
1196 | space = isl_space_set_alloc(ctx, 0, 5); |
1197 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1198 | ls = isl_local_space_from_space(space); |
1199 | |
1200 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1201 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1202 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3); |
1203 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 3, -3); |
1204 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 4, 6); |
1205 | bset = isl_basic_set_add_constraint(bset, c); |
1206 | |
1207 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1208 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1209 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 1); |
1210 | c = isl_constraint_set_constant_si(c, 1); |
1211 | bset = isl_basic_set_add_constraint(bset, c); |
1212 | |
1213 | bset = isl_basic_set_project_out(bset, isl_dim_set, 4, 1); |
1214 | |
1215 | /* Test disabled for now */ |
1216 | /* |
1217 | assert(bset && bset->n_div == 1); |
1218 | */ |
1219 | isl_local_space_free(ls); |
1220 | isl_basic_set_free(bset); |
1221 | |
1222 | /* test 9 */ |
1223 | space = isl_space_set_alloc(ctx, 0, 4); |
1224 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1225 | ls = isl_local_space_from_space(space); |
1226 | |
1227 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1228 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1); |
1229 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -1); |
1230 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, -2); |
1231 | bset = isl_basic_set_add_constraint(bset, c); |
1232 | |
1233 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1234 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1); |
1235 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 3, 3); |
1236 | c = isl_constraint_set_constant_si(c, 2); |
1237 | bset = isl_basic_set_add_constraint(bset, c); |
1238 | |
1239 | bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 2); |
1240 | |
1241 | bset = isl_basic_set_fix_si(bset, isl_dim_set, 0, 2); |
1242 | |
1243 | assert(!isl_basic_set_is_empty(bset))((void) sizeof ((!isl_basic_set_is_empty(bset)) ? 1 : 0), __extension__ ({ if (!isl_basic_set_is_empty(bset)) ; else __assert_fail ( "!isl_basic_set_is_empty(bset)", "polly/lib/External/isl/isl_test.c" , 1243, __extension__ __PRETTY_FUNCTION__); })); |
1244 | |
1245 | isl_local_space_free(ls); |
1246 | isl_basic_set_free(bset); |
1247 | |
1248 | /* test 10 */ |
1249 | space = isl_space_set_alloc(ctx, 0, 3); |
1250 | bset = isl_basic_set_universe(isl_space_copy(space)); |
1251 | ls = isl_local_space_from_space(space); |
1252 | |
1253 | c = isl_constraint_alloc_equality(isl_local_space_copy(ls)); |
1254 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1); |
1255 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, -2); |
1256 | bset = isl_basic_set_add_constraint(bset, c); |
1257 | |
1258 | bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 1); |
1259 | |
1260 | bset = isl_basic_set_fix_si(bset, isl_dim_set, 0, 2); |
1261 | |
1262 | isl_local_space_free(ls); |
1263 | isl_basic_set_free(bset); |
1264 | |
1265 | str = "{ [i] : exists (e0, e1: 3e1 >= 1 + 2e0 and " |
1266 | "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }"; |
1267 | set = isl_set_read_from_str(ctx, str); |
1268 | set = isl_set_compute_divs(set); |
1269 | isl_set_free(set); |
1270 | if (!set) |
1271 | return -1; |
1272 | |
1273 | if (test_elimination(ctx) < 0) |
1274 | return -1; |
1275 | |
1276 | str = "{ [i,j,k] : 3 + i + 2j >= 0 and 2 * [(i+2j)/4] <= k }"; |
1277 | set = isl_set_read_from_str(ctx, str); |
1278 | set = isl_set_remove_divs_involving_dims(set, isl_dim_set, 0, 2); |
1279 | set = isl_set_fix_si(set, isl_dim_set, 2, -3); |
1280 | empty = isl_set_is_empty(set); |
1281 | isl_set_free(set); |
1282 | if (empty < 0) |
1283 | return -1; |
1284 | if (!empty) |
1285 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "result not as accurate as expected" , "polly/lib/External/isl/isl_test.c", 1286); return -1; } while (0) |
1286 | "result not as accurate as expected", return -1)do { isl_handle_error(ctx, isl_error_unknown, "result not as accurate as expected" , "polly/lib/External/isl/isl_test.c", 1286); return -1; } while (0); |
1287 | |
1288 | return 0; |
1289 | } |
1290 | |
1291 | void test_application_case(struct isl_ctx *ctx, const char *name) |
1292 | { |
1293 | char *filename; |
1294 | FILE *input; |
1295 | struct isl_basic_setisl_basic_map *bset1, *bset2; |
1296 | struct isl_basic_map *bmap; |
1297 | |
1298 | filename = get_filename(ctx, name, "omega"); |
1299 | assert(filename)((void) sizeof ((filename) ? 1 : 0), __extension__ ({ if (filename ) ; else __assert_fail ("filename", "polly/lib/External/isl/isl_test.c" , 1299, __extension__ __PRETTY_FUNCTION__); })); |
1300 | input = fopen(filename, "r"); |
1301 | assert(input)((void) sizeof ((input) ? 1 : 0), __extension__ ({ if (input) ; else __assert_fail ("input", "polly/lib/External/isl/isl_test.c" , 1301, __extension__ __PRETTY_FUNCTION__); })); |
1302 | |
1303 | bset1 = isl_basic_set_read_from_file(ctx, input); |
1304 | bmap = isl_basic_map_read_from_file(ctx, input); |
1305 | |
1306 | bset1 = isl_basic_set_apply(bset1, bmap); |
1307 | |
1308 | bset2 = isl_basic_set_read_from_file(ctx, input); |
1309 | |
1310 | assert(isl_basic_set_is_equal(bset1, bset2) == 1)((void) sizeof ((isl_basic_set_is_equal(bset1, bset2) == 1) ? 1 : 0), __extension__ ({ if (isl_basic_set_is_equal(bset1, bset2 ) == 1) ; else __assert_fail ("isl_basic_set_is_equal(bset1, bset2) == 1" , "polly/lib/External/isl/isl_test.c", 1310, __extension__ __PRETTY_FUNCTION__ ); })); |
1311 | |
1312 | isl_basic_set_free(bset1); |
1313 | isl_basic_set_free(bset2); |
1314 | free(filename); |
1315 | |
1316 | fclose(input); |
1317 | } |
1318 | |
1319 | static int test_application(isl_ctx *ctx) |
1320 | { |
1321 | test_application_case(ctx, "application"); |
1322 | test_application_case(ctx, "application2"); |
1323 | |
1324 | return 0; |
1325 | } |
1326 | |
1327 | void test_affine_hull_case(struct isl_ctx *ctx, const char *name) |
1328 | { |
1329 | char *filename; |
1330 | FILE *input; |
1331 | struct isl_basic_setisl_basic_map *bset1, *bset2; |
1332 | |
1333 | filename = get_filename(ctx, name, "polylib"); |
1334 | assert(filename)((void) sizeof ((filename) ? 1 : 0), __extension__ ({ if (filename ) ; else __assert_fail ("filename", "polly/lib/External/isl/isl_test.c" , 1334, __extension__ __PRETTY_FUNCTION__); })); |
1335 | input = fopen(filename, "r"); |
1336 | assert(input)((void) sizeof ((input) ? 1 : 0), __extension__ ({ if (input) ; else __assert_fail ("input", "polly/lib/External/isl/isl_test.c" , 1336, __extension__ __PRETTY_FUNCTION__); })); |
1337 | |
1338 | bset1 = isl_basic_set_read_from_file(ctx, input); |
1339 | bset2 = isl_basic_set_read_from_file(ctx, input); |
1340 | |
1341 | bset1 = isl_basic_set_affine_hull(bset1); |
1342 | |
1343 | assert(isl_basic_set_is_equal(bset1, bset2) == 1)((void) sizeof ((isl_basic_set_is_equal(bset1, bset2) == 1) ? 1 : 0), __extension__ ({ if (isl_basic_set_is_equal(bset1, bset2 ) == 1) ; else __assert_fail ("isl_basic_set_is_equal(bset1, bset2) == 1" , "polly/lib/External/isl/isl_test.c", 1343, __extension__ __PRETTY_FUNCTION__ ); })); |
1344 | |
1345 | isl_basic_set_free(bset1); |
1346 | isl_basic_set_free(bset2); |
1347 | free(filename); |
1348 | |
1349 | fclose(input); |
1350 | } |
1351 | |
1352 | /* Pairs of sets and the corresponding expected results of |
1353 | * isl_basic_set_recession_cone. |
1354 | */ |
1355 | struct { |
1356 | const char *set; |
1357 | const char *cone; |
1358 | } recession_cone_tests[] = { |
1359 | { "{ [i] : 0 <= i <= 10 }", "{ [0] }" }, |
1360 | { "{ [i] : 0 <= i }", "{ [i] : 0 <= i }" }, |
1361 | { "{ [i] : i <= 10 }", "{ [i] : i <= 0 }" }, |
1362 | { "{ [i] : false }", "{ [i] : false }" }, |
1363 | }; |
1364 | |
1365 | /* Perform some basic isl_basic_set_recession_cone tests. |
1366 | */ |
1367 | static int test_recession_cone(struct isl_ctx *ctx) |
1368 | { |
1369 | int i; |
1370 | |
1371 | for (i = 0; i < ARRAY_SIZE(recession_cone_tests)(sizeof(recession_cone_tests)/sizeof(*recession_cone_tests)); ++i) { |
1372 | const char *str; |
1373 | isl_basic_setisl_basic_map *bset; |
1374 | isl_basic_setisl_basic_map *cone, *expected; |
1375 | isl_bool equal; |
1376 | |
1377 | str = recession_cone_tests[i].set; |
1378 | bset = isl_basic_set_read_from_str(ctx, str); |
1379 | str = recession_cone_tests[i].cone; |
1380 | expected = isl_basic_set_read_from_str(ctx, str); |
1381 | cone = isl_basic_set_recession_cone(bset); |
1382 | equal = isl_basic_set_is_equal(cone, expected); |
1383 | isl_basic_set_free(cone); |
1384 | isl_basic_set_free(expected); |
1385 | if (equal < 0) |
1386 | return -1; |
1387 | if (!equal) |
1388 | isl_die(ctx, isl_error_unknown, "unexpected cone",do { isl_handle_error(ctx, isl_error_unknown, "unexpected cone" , "polly/lib/External/isl/isl_test.c", 1389); return -1; } while (0) |
1389 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected cone" , "polly/lib/External/isl/isl_test.c", 1389); return -1; } while (0); |
1390 | } |
1391 | |
1392 | return 0; |
1393 | } |
1394 | |
1395 | int test_affine_hull(struct isl_ctx *ctx) |
1396 | { |
1397 | const char *str; |
1398 | isl_setisl_map *set; |
1399 | isl_basic_setisl_basic_map *bset, *bset2; |
1400 | isl_size n; |
1401 | isl_bool subset; |
1402 | |
1403 | test_affine_hull_case(ctx, "affine2"); |
1404 | test_affine_hull_case(ctx, "affine"); |
1405 | test_affine_hull_case(ctx, "affine3"); |
1406 | |
1407 | str = "[m] -> { [i0] : exists (e0, e1: e1 <= 1 + i0 and " |
1408 | "m >= 3 and 4i0 <= 2 + m and e1 >= i0 and " |
1409 | "e1 >= 0 and e1 <= 2 and e1 >= 1 + 2e0 and " |
1410 | "2e1 <= 1 + m + 4e0 and 2e1 >= 2 - m + 4i0 - 4e0) }"; |
1411 | set = isl_set_read_from_str(ctx, str); |
1412 | bset = isl_set_affine_hull(set); |
1413 | n = isl_basic_set_dim(bset, isl_dim_div); |
1414 | isl_basic_set_free(bset); |
1415 | if (n < 0) |
1416 | return -1; |
1417 | if (n != 0) |
1418 | isl_die(ctx, isl_error_unknown, "not expecting any divs",do { isl_handle_error(ctx, isl_error_unknown, "not expecting any divs" , "polly/lib/External/isl/isl_test.c", 1419); return -1; } while (0) |
1419 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "not expecting any divs" , "polly/lib/External/isl/isl_test.c", 1419); return -1; } while (0); |
1420 | |
1421 | /* Check that isl_map_affine_hull is not confused by |
1422 | * the reordering of divs in isl_map_align_divs. |
1423 | */ |
1424 | str = "{ [a, b, c, 0] : exists (e0 = [(b)/32], e1 = [(c)/32]: " |
1425 | "32e0 = b and 32e1 = c); " |
1426 | "[a, 0, c, 0] : exists (e0 = [(c)/32]: 32e0 = c) }"; |
1427 | set = isl_set_read_from_str(ctx, str); |
1428 | bset = isl_set_affine_hull(set); |
1429 | isl_basic_set_free(bset); |
1430 | if (!bset) |
1431 | return -1; |
1432 | |
1433 | str = "{ [a] : exists e0, e1, e2: 32e1 = 31 + 31a + 31e0 and " |
1434 | "32e2 = 31 + 31e0 }"; |
1435 | set = isl_set_read_from_str(ctx, str); |
1436 | bset = isl_set_affine_hull(set); |
1437 | str = "{ [a] : exists e : a = 32 e }"; |
1438 | bset2 = isl_basic_set_read_from_str(ctx, str); |
1439 | subset = isl_basic_set_is_subset(bset, bset2); |
1440 | isl_basic_set_free(bset); |
1441 | isl_basic_set_free(bset2); |
1442 | if (subset < 0) |
1443 | return -1; |
1444 | if (!subset) |
1445 | isl_die(ctx, isl_error_unknown, "not as accurate as expected",do { isl_handle_error(ctx, isl_error_unknown, "not as accurate as expected" , "polly/lib/External/isl/isl_test.c", 1446); return -1; } while (0) |
1446 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "not as accurate as expected" , "polly/lib/External/isl/isl_test.c", 1446); return -1; } while (0); |
1447 | |
1448 | return 0; |
1449 | } |
1450 | |
1451 | /* Test a special case of isl_set_plain_unshifted_simple_hull |
1452 | * where older versions of isl would include a redundant constraint |
1453 | * in the result. |
1454 | * Check that the result does not have any constraints. |
1455 | */ |
1456 | static isl_stat test_plain_unshifted_simple_hull_special(isl_ctx *ctx) |
1457 | { |
1458 | const char *str; |
1459 | isl_bool is_universe; |
1460 | isl_setisl_map *set; |
1461 | isl_basic_setisl_basic_map *bset; |
1462 | |
1463 | str = "{[x, y] : x = 0 or 2*((x+y)//2) <= y + 2 }"; |
1464 | set = isl_set_read_from_str(ctx, str); |
1465 | bset = isl_set_plain_unshifted_simple_hull(set); |
1466 | is_universe = isl_basic_set_plain_is_universe(bset); |
1467 | isl_basic_set_free(bset); |
1468 | |
1469 | if (is_universe < 0) |
1470 | return isl_stat_error; |
1471 | if (!is_universe) |
1472 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "hull should not have any constraints" , "polly/lib/External/isl/isl_test.c", 1474); return isl_stat_error ; } while (0) |
1473 | "hull should not have any constraints",do { isl_handle_error(ctx, isl_error_unknown, "hull should not have any constraints" , "polly/lib/External/isl/isl_test.c", 1474); return isl_stat_error ; } while (0) |
1474 | return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "hull should not have any constraints" , "polly/lib/External/isl/isl_test.c", 1474); return isl_stat_error ; } while (0); |
1475 | |
1476 | return isl_stat_ok; |
1477 | } |
1478 | |
1479 | /* Inputs for simple hull tests, consisting of |
1480 | * the specific simple hull function, the input set and the expected result. |
1481 | */ |
1482 | struct { |
1483 | __isl_give isl_basic_setisl_basic_map *(*fn)(__isl_take isl_setisl_map *set); |
1484 | const char *set; |
1485 | const char *hull; |
1486 | } simple_hull_tests[] = { |
1487 | { &isl_set_plain_unshifted_simple_hull, |
1488 | "{ [i,j] : i >= 1 and j >= 1 or i >= 2 and j <= 10 }", |
1489 | "{ [i,j] : i >= 1 }" }, |
1490 | { &isl_set_plain_unshifted_simple_hull, |
1491 | "{ [n,i,j,k] : (i mod 3 = 2 and j mod 4 = 2) or " |
1492 | "(j mod 4 = 2 and k mod 6 = n) }", |
1493 | "{ [n,i,j,k] : j mod 4 = 2 }" }, |
1494 | { &isl_set_unshifted_simple_hull, |
1495 | "{ [0,x,y] : x <= -1; [1,x,y] : x <= y <= -x; [2,x,y] : x <= 1 }", |
1496 | "{ [t,x,y] : 0 <= t <= 2 and x <= 1 }" }, |
1497 | { &isl_set_simple_hull, |
1498 | "{ [a, b] : b <= 0 and " |
1499 | "2*floor((-2*floor((b)/2))/5) >= a - floor((b)/2); " |
1500 | "[a, b] : a mod 2 = 0 }", |
1501 | "{ [a, b] }" }, |
1502 | }; |
1503 | |
1504 | /* Basic tests for various simple hull functions. |
1505 | */ |
1506 | static int test_various_simple_hull(isl_ctx *ctx) |
1507 | { |
1508 | int i; |
1509 | isl_setisl_map *set; |
1510 | isl_basic_setisl_basic_map *hull, *expected; |
1511 | isl_bool equal; |
1512 | |
1513 | for (i = 0; i < ARRAY_SIZE(simple_hull_tests)(sizeof(simple_hull_tests)/sizeof(*simple_hull_tests)); ++i) { |
1514 | const char *str; |
1515 | str = simple_hull_tests[i].set; |
1516 | set = isl_set_read_from_str(ctx, str); |
1517 | str = simple_hull_tests[i].hull; |
1518 | expected = isl_basic_set_read_from_str(ctx, str); |
1519 | hull = simple_hull_tests[i].fn(set); |
1520 | equal = isl_basic_set_is_equal(hull, expected); |
1521 | isl_basic_set_free(hull); |
1522 | isl_basic_set_free(expected); |
1523 | if (equal < 0) |
1524 | return -1; |
1525 | if (!equal) |
1526 | isl_die(ctx, isl_error_unknown, "unexpected hull",do { isl_handle_error(ctx, isl_error_unknown, "unexpected hull" , "polly/lib/External/isl/isl_test.c", 1527); return -1; } while (0) |
1527 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected hull" , "polly/lib/External/isl/isl_test.c", 1527); return -1; } while (0); |
1528 | } |
1529 | |
1530 | return 0; |
1531 | } |
1532 | |
1533 | static int test_simple_hull(struct isl_ctx *ctx) |
1534 | { |
1535 | const char *str; |
1536 | isl_setisl_map *set; |
1537 | isl_basic_setisl_basic_map *bset; |
1538 | isl_bool is_empty; |
1539 | |
1540 | str = "{ [x, y] : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x;" |
1541 | "[y, x] : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x }"; |
1542 | set = isl_set_read_from_str(ctx, str); |
1543 | bset = isl_set_simple_hull(set); |
1544 | is_empty = isl_basic_set_is_empty(bset); |
1545 | isl_basic_set_free(bset); |
1546 | |
1547 | if (is_empty == isl_bool_error) |
1548 | return -1; |
1549 | |
1550 | if (is_empty == isl_bool_false) |
1551 | isl_die(ctx, isl_error_unknown, "Empty set should be detected",do { isl_handle_error(ctx, isl_error_unknown, "Empty set should be detected" , "polly/lib/External/isl/isl_test.c", 1552); return -1; } while (0) |
1552 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "Empty set should be detected" , "polly/lib/External/isl/isl_test.c", 1552); return -1; } while (0); |
1553 | |
1554 | if (test_plain_unshifted_simple_hull_special(ctx) < 0) |
1555 | return -1; |
1556 | if (test_various_simple_hull(ctx) < 0) |
1557 | return -1; |
1558 | |
1559 | return 0; |
1560 | } |
1561 | |
1562 | /* Inputs for isl_set_get_simple_fixed_box_hull tests. |
1563 | * "set" is the input set. |
1564 | * "offset" is the expected box offset. |
1565 | * "size" is the expected box size. |
1566 | */ |
1567 | static struct { |
1568 | const char *set; |
1569 | const char *offset; |
1570 | const char *size; |
1571 | } box_hull_tests[] = { |
1572 | { "{ S[x, y] : 0 <= x, y < 10 }", "{ S[0, 0] }", "{ S[10, 10] }" }, |
1573 | { "[N] -> { S[x, y] : N <= x, y < N + 10 }", |
1574 | "[N] -> { S[N, N] }", "{ S[10, 10] }" }, |
1575 | { "{ S[x, y] : 0 <= x + y, x - y < 10 }", |
1576 | "{ S[0, -4] }", "{ S[10, 9] }" }, |
1577 | { "{ [i=0:10] : exists (e0, e1: 3e1 >= 1 + 2e0 and " |
1578 | "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }", |
1579 | "{ [3] }", "{ [8] }" }, |
1580 | { "[N] -> { [w = 0:17] : exists (e0: w < 2N and " |
1581 | "-1 + w <= e0 <= w and 2e0 >= N + w and w <= 2e0 <= 15 + w) }", |
1582 | "[N] -> { [N] }", "{ [9] }" }, |
1583 | }; |
1584 | |
1585 | /* Perform basic isl_set_get_simple_fixed_box_hull tests. |
1586 | */ |
1587 | static int test_box_hull(struct isl_ctx *ctx) |
1588 | { |
1589 | int i; |
1590 | |
1591 | for (i = 0; i < ARRAY_SIZE(box_hull_tests)(sizeof(box_hull_tests)/sizeof(*box_hull_tests)); ++i) { |
1592 | const char *str; |
1593 | isl_stat r; |
1594 | isl_setisl_map *set; |
1595 | isl_multi_aff *offset; |
1596 | isl_multi_val *size; |
1597 | isl_fixed_box *box; |
1598 | |
1599 | set = isl_set_read_from_str(ctx, box_hull_tests[i].set); |
1600 | box = isl_set_get_simple_fixed_box_hull(set); |
1601 | offset = isl_fixed_box_get_offset(box); |
1602 | size = isl_fixed_box_get_size(box); |
1603 | str = box_hull_tests[i].offset; |
1604 | r = multi_aff_check_plain_equal(offset, str); |
1605 | str = box_hull_tests[i].size; |
1606 | if (r >= 0) |
1607 | r = multi_val_check_plain_equal(size, str); |
1608 | isl_multi_aff_free(offset); |
1609 | isl_multi_val_free(size); |
1610 | isl_fixed_box_free(box); |
1611 | isl_set_free(set); |
1612 | if (r < 0) |
1613 | return -1; |
1614 | } |
1615 | |
1616 | return 0; |
1617 | } |
1618 | |
1619 | void test_convex_hull_case(struct isl_ctx *ctx, const char *name) |
1620 | { |
1621 | char *filename; |
1622 | FILE *input; |
1623 | struct isl_basic_setisl_basic_map *bset1, *bset2; |
1624 | struct isl_setisl_map *set; |
1625 | |
1626 | filename = get_filename(ctx, name, "polylib"); |
1627 | assert(filename)((void) sizeof ((filename) ? 1 : 0), __extension__ ({ if (filename ) ; else __assert_fail ("filename", "polly/lib/External/isl/isl_test.c" , 1627, __extension__ __PRETTY_FUNCTION__); })); |
1628 | input = fopen(filename, "r"); |
1629 | assert(input)((void) sizeof ((input) ? 1 : 0), __extension__ ({ if (input) ; else __assert_fail ("input", "polly/lib/External/isl/isl_test.c" , 1629, __extension__ __PRETTY_FUNCTION__); })); |
1630 | |
1631 | bset1 = isl_basic_set_read_from_file(ctx, input); |
1632 | bset2 = isl_basic_set_read_from_file(ctx, input); |
1633 | |
1634 | set = isl_basic_set_union(bset1, bset2); |
1635 | bset1 = isl_set_convex_hull(set); |
1636 | |
1637 | bset2 = isl_basic_set_read_from_file(ctx, input); |
1638 | |
1639 | assert(isl_basic_set_is_equal(bset1, bset2) == 1)((void) sizeof ((isl_basic_set_is_equal(bset1, bset2) == 1) ? 1 : 0), __extension__ ({ if (isl_basic_set_is_equal(bset1, bset2 ) == 1) ; else __assert_fail ("isl_basic_set_is_equal(bset1, bset2) == 1" , "polly/lib/External/isl/isl_test.c", 1639, __extension__ __PRETTY_FUNCTION__ ); })); |
1640 | |
1641 | isl_basic_set_free(bset1); |
1642 | isl_basic_set_free(bset2); |
1643 | free(filename); |
1644 | |
1645 | fclose(input); |
1646 | } |
1647 | |
1648 | struct { |
1649 | const char *set; |
1650 | const char *hull; |
1651 | } convex_hull_tests[] = { |
1652 | { "{ [i0, i1, i2] : (i2 = 1 and i0 = 0 and i1 >= 0) or " |
1653 | "(i0 = 1 and i1 = 0 and i2 = 1) or " |
1654 | "(i0 = 0 and i1 = 0 and i2 = 0) }", |
1655 | "{ [i0, i1, i2] : i0 >= 0 and i2 >= i0 and i2 <= 1 and i1 >= 0 }" }, |
1656 | { "[n] -> { [i0, i1, i0] : i0 <= -4 + n; " |
1657 | "[i0, i0, i2] : n = 6 and i0 >= 0 and i2 <= 7 - i0 and " |
1658 | "i2 <= 5 and i2 >= 4; " |
1659 | "[3, i1, 3] : n = 5 and i1 <= 2 and i1 >= 0 }", |
1660 | "[n] -> { [i0, i1, i2] : i2 <= -1 + n and 2i2 <= -6 + 3n - i0 and " |
1661 | "i2 <= 5 + i0 and i2 >= i0 }" }, |
1662 | { "{ [x, y] : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x }", |
1663 | "{ [x, y] : 1 = 0 }" }, |
1664 | { "{ [x, y, z] : 0 <= x, y, z <= 10; [x, y, 0] : x >= 0 and y > 0; " |
1665 | "[x, y, 0] : x >= 0 and y < 0 }", |
1666 | "{ [x, y, z] : x >= 0 and 0 <= z <= 10 }" }, |
1667 | { "{ [a, b, c] : a <= 1 and -a < b <= 1 and 0 <= c <= 2 - a - b and " |
1668 | "c <= a; " |
1669 | "[0, 2, 0]; [3, 1, 0] }", |
1670 | "{ [a, b, c] : b > -a and 2b >= -1 + a and 0 <= c <= a and " |
1671 | "5c <= 6 - a - 3b }" }, |
1672 | }; |
1673 | |
1674 | static int test_convex_hull_algo(isl_ctx *ctx, int convex) |
1675 | { |
1676 | int i; |
1677 | int orig_convex = ctx->opt->convex; |
1678 | ctx->opt->convex = convex; |
1679 | |
1680 | test_convex_hull_case(ctx, "convex0"); |
1681 | test_convex_hull_case(ctx, "convex1"); |
1682 | test_convex_hull_case(ctx, "convex2"); |
1683 | test_convex_hull_case(ctx, "convex3"); |
1684 | test_convex_hull_case(ctx, "convex4"); |
1685 | test_convex_hull_case(ctx, "convex5"); |
1686 | test_convex_hull_case(ctx, "convex6"); |
1687 | test_convex_hull_case(ctx, "convex7"); |
1688 | test_convex_hull_case(ctx, "convex8"); |
1689 | test_convex_hull_case(ctx, "convex9"); |
1690 | test_convex_hull_case(ctx, "convex10"); |
1691 | test_convex_hull_case(ctx, "convex11"); |
1692 | test_convex_hull_case(ctx, "convex12"); |
1693 | test_convex_hull_case(ctx, "convex13"); |
1694 | test_convex_hull_case(ctx, "convex14"); |
1695 | test_convex_hull_case(ctx, "convex15"); |
1696 | |
1697 | for (i = 0; i < ARRAY_SIZE(convex_hull_tests)(sizeof(convex_hull_tests)/sizeof(*convex_hull_tests)); ++i) { |
1698 | isl_setisl_map *set1, *set2; |
1699 | int equal; |
1700 | |
1701 | set1 = isl_set_read_from_str(ctx, convex_hull_tests[i].set); |
1702 | set2 = isl_set_read_from_str(ctx, convex_hull_tests[i].hull); |
1703 | set1 = isl_set_from_basic_set(isl_set_convex_hull(set1)); |
1704 | equal = isl_set_is_equal(set1, set2); |
1705 | isl_set_free(set1); |
1706 | isl_set_free(set2); |
1707 | |
1708 | if (equal < 0) |
1709 | return -1; |
1710 | if (!equal) |
1711 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected convex hull" , "polly/lib/External/isl/isl_test.c", 1712); return -1; } while (0) |
1712 | "unexpected convex hull", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected convex hull" , "polly/lib/External/isl/isl_test.c", 1712); return -1; } while (0); |
1713 | } |
1714 | |
1715 | ctx->opt->convex = orig_convex; |
1716 | |
1717 | return 0; |
1718 | } |
1719 | |
1720 | static int test_convex_hull(isl_ctx *ctx) |
1721 | { |
1722 | if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_FM1) < 0) |
1723 | return -1; |
1724 | if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_WRAP0) < 0) |
1725 | return -1; |
1726 | return 0; |
1727 | } |
1728 | |
1729 | /* Check that computing the gist of "map" with respect to "context" |
1730 | * does not make any copy of "map" get marked empty. |
1731 | * Earlier versions of isl would end up doing that. |
1732 | */ |
1733 | static isl_stat test_gist_empty_pair(isl_ctx *ctx, const char *map, |
1734 | const char *context) |
1735 | { |
1736 | isl_map *m1, *m2, *m3; |
1737 | isl_bool empty_before, empty_after; |
1738 | |
1739 | m1 = isl_map_read_from_str(ctx, map); |
1740 | m2 = isl_map_read_from_str(ctx, context); |
1741 | m3 = isl_map_copy(m1); |
1742 | empty_before = isl_map_is_empty(m3); |
1743 | m1 = isl_map_gist(m1, m2); |
1744 | empty_after = isl_map_is_empty(m3); |
1745 | isl_map_free(m1); |
1746 | isl_map_free(m3); |
1747 | |
1748 | if (empty_before < 0 || empty_after < 0) |
1749 | return isl_stat_error; |
1750 | if (empty_before) |
1751 | isl_die(ctx, isl_error_unknown, "map should not be empty",do { isl_handle_error(ctx, isl_error_unknown, "map should not be empty" , "polly/lib/External/isl/isl_test.c", 1752); return isl_stat_error ; } while (0) |
1752 | return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "map should not be empty" , "polly/lib/External/isl/isl_test.c", 1752); return isl_stat_error ; } while (0); |
1753 | if (empty_after) |
1754 | isl_die(ctx, isl_error_unknown, "map should still not be empty",do { isl_handle_error(ctx, isl_error_unknown, "map should still not be empty" , "polly/lib/External/isl/isl_test.c", 1755); return isl_stat_error ; } while (0) |
1755 | return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "map should still not be empty" , "polly/lib/External/isl/isl_test.c", 1755); return isl_stat_error ; } while (0); |
1756 | |
1757 | return isl_stat_ok; |
1758 | } |
1759 | |
1760 | /* Check that computing a gist does not make any copy of the input |
1761 | * get marked empty. |
1762 | * Earlier versions of isl would end up doing that on some pairs of inputs. |
1763 | */ |
1764 | static isl_stat test_gist_empty(isl_ctx *ctx) |
1765 | { |
1766 | const char *map, *context; |
1767 | |
1768 | map = "{ [] -> [a, b, c] : 2b = 1 + a }"; |
1769 | context = "{ [] -> [a, b, c] : 2c = 2 + a }"; |
1770 | if (test_gist_empty_pair(ctx, map, context) < 0) |
1771 | return isl_stat_error; |
1772 | map = "{ [] -> [0, 0] }"; |
1773 | context = "{ [] -> [a, b] : a > b }"; |
1774 | if (test_gist_empty_pair(ctx, map, context) < 0) |
1775 | return isl_stat_error; |
1776 | |
1777 | return isl_stat_ok; |
1778 | } |
1779 | |
1780 | /* Inputs to isl_map_plain_gist_basic_map, along with the expected output. |
1781 | */ |
1782 | struct { |
1783 | const char *map; |
1784 | const char *context; |
1785 | const char *gist; |
1786 | } plain_gist_tests[] = { |
1787 | { "{ [i] -> [j] : i >= 1 and j >= 1 or i >= 2 and j <= 10 }", |
1788 | "{ [i] -> [j] : i >= 1 }", |
1789 | "{ [i] -> [j] : j >= 1 or i >= 2 and j <= 10 }" }, |
1790 | { "{ [n] -> [i,j,k] : (i mod 3 = 2 and j mod 4 = 2) or " |
1791 | "(j mod 4 = 2 and k mod 6 = n) }", |
1792 | "{ [n] -> [i,j,k] : j mod 4 = 2 }", |
1793 | "{ [n] -> [i,j,k] : (i mod 3 = 2) or (k mod 6 = n) }" }, |
1794 | { "{ [i] -> [j] : i > j and (exists a,b : i <= 2a + 5b <= 2) }", |
1795 | "{ [i] -> [j] : i > j }", |
1796 | "{ [i] -> [j] : exists a,b : i <= 2a + 5b <= 2 }" }, |
1797 | }; |
1798 | |
1799 | /* Basic tests for isl_map_plain_gist_basic_map. |
1800 | */ |
1801 | static int test_plain_gist(isl_ctx *ctx) |
1802 | { |
1803 | int i; |
1804 | |
1805 | for (i = 0; i < ARRAY_SIZE(plain_gist_tests)(sizeof(plain_gist_tests)/sizeof(*plain_gist_tests)); ++i) { |
1806 | const char *str; |
1807 | int equal; |
1808 | isl_map *map, *gist; |
1809 | isl_basic_map *context; |
1810 | |
1811 | map = isl_map_read_from_str(ctx, plain_gist_tests[i].map); |
1812 | str = plain_gist_tests[i].context; |
1813 | context = isl_basic_map_read_from_str(ctx, str); |
1814 | map = isl_map_plain_gist_basic_map(map, context); |
1815 | gist = isl_map_read_from_str(ctx, plain_gist_tests[i].gist); |
1816 | equal = isl_map_is_equal(map, gist); |
1817 | isl_map_free(map); |
1818 | isl_map_free(gist); |
1819 | if (equal < 0) |
1820 | return -1; |
1821 | if (!equal) |
1822 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect gist result" , "polly/lib/External/isl/isl_test.c", 1823); return -1; } while (0) |
1823 | "incorrect gist result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect gist result" , "polly/lib/External/isl/isl_test.c", 1823); return -1; } while (0); |
1824 | } |
1825 | |
1826 | return 0; |
1827 | } |
1828 | |
1829 | /* Inputs for isl_basic_set_gist tests that are expected to fail. |
1830 | */ |
1831 | struct { |
1832 | const char *set; |
1833 | const char *context; |
1834 | } gist_fail_tests[] = { |
1835 | { "{ [i] : exists (e0, e1: 3e1 >= 1 + 2e0 and " |
1836 | "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }", |
1837 | "{ [i] : i >= 0 }" }, |
1838 | }; |
1839 | |
1840 | /* Check that isl_basic_set_gist fails (gracefully) when expected. |
1841 | * In particular, the user should be able to recover from the failure. |
1842 | */ |
1843 | static isl_stat test_gist_fail(struct isl_ctx *ctx) |
1844 | { |
1845 | int i, n; |
1846 | int on_error; |
1847 | |
1848 | on_error = isl_options_get_on_error(ctx); |
1849 | isl_options_set_on_error(ctx, ISL_ON_ERROR_CONTINUE1); |
1850 | n = ARRAY_SIZE(gist_fail_tests)(sizeof(gist_fail_tests)/sizeof(*gist_fail_tests)); |
1851 | for (i = 0; i < n; ++i) { |
1852 | const char *str; |
1853 | isl_basic_setisl_basic_map *bset, *context; |
1854 | |
1855 | bset = isl_basic_set_read_from_str(ctx, gist_fail_tests[i].set); |
1856 | str = gist_fail_tests[i].context; |
1857 | context = isl_basic_set_read_from_str(ctx, str); |
1858 | bset = isl_basic_set_gist(bset, context); |
1859 | isl_basic_set_free(bset); |
1860 | if (bset) |
1861 | break; |
1862 | } |
1863 | isl_options_set_on_error(ctx, on_error); |
1864 | if (i < n) |
1865 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed" , "polly/lib/External/isl/isl_test.c", 1867); return isl_stat_error ; } while (0) |
1866 | "operation not expected to succeed",do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed" , "polly/lib/External/isl/isl_test.c", 1867); return isl_stat_error ; } while (0) |
1867 | return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed" , "polly/lib/External/isl/isl_test.c", 1867); return isl_stat_error ; } while (0); |
1868 | |
1869 | return isl_stat_ok; |
1870 | } |
1871 | |
1872 | struct { |
1873 | const char *set; |
1874 | const char *context; |
1875 | const char *gist; |
1876 | } gist_tests[] = { |
1877 | { "{ [1, -1, 3] }", |
1878 | "{ [1, b, 2 - b] : -1 <= b <= 2 }", |
1879 | "{ [a, -1, c] }" }, |
1880 | { "{ [a, b, c] : a <= 15 and a >= 1 }", |
1881 | "{ [a, b, c] : exists (e0 = floor((-1 + a)/16): a >= 1 and " |
1882 | "c <= 30 and 32e0 >= -62 + 2a + 2b - c and b >= 0) }", |
1883 | "{ [a, b, c] : a <= 15 }" }, |
1884 | { "{ : }", "{ : 1 = 0 }", "{ : }" }, |
1885 | { "{ : 1 = 0 }", "{ : 1 = 0 }", "{ : }" }, |
1886 | { "[M] -> { [x] : exists (e0 = floor((-2 + x)/3): 3e0 = -2 + x) }", |
1887 | "[M] -> { [3M] }" , "[M] -> { [x] : 1 = 0 }" }, |
1888 | { "{ [m, n, a, b] : a <= 2147 + n }", |
1889 | "{ [m, n, a, b] : (m >= 1 and n >= 1 and a <= 2148 - m and " |
1890 | "b <= 2148 - n and b >= 0 and b >= 2149 - n - a) or " |
1891 | "(n >= 1 and a >= 0 and b <= 2148 - n - a and " |
1892 | "b >= 0) }", |
1893 | "{ [m, n, ku, kl] }" }, |
1894 | { "{ [a, a, b] : a >= 10 }", |
1895 | "{ [a, b, c] : c >= a and c <= b and c >= 2 }", |
1896 | "{ [a, a, b] : a >= 10 }" }, |
1897 | { "{ [i, j] : i >= 0 and i + j >= 0 }", "{ [i, j] : i <= 0 }", |
1898 | "{ [0, j] : j >= 0 }" }, |
1899 | /* Check that no constraints on i6 are introduced in the gist */ |
1900 | { "[t1] -> { [i4, i6] : exists (e0 = floor((1530 - 4t1 - 5i4)/20): " |
1901 | "20e0 <= 1530 - 4t1 - 5i4 and 20e0 >= 1511 - 4t1 - 5i4 and " |
1902 | "5e0 <= 381 - t1 and i4 <= 1) }", |
1903 | "[t1] -> { [i4, i6] : exists (e0 = floor((-t1 + i6)/5): " |
1904 | "5e0 = -t1 + i6 and i6 <= 6 and i6 >= 3) }", |
1905 | "[t1] -> { [i4, i6] : exists (e0 = floor((1530 - 4t1 - 5i4)/20): " |
1906 | "i4 <= 1 and 5e0 <= 381 - t1 and 20e0 <= 1530 - 4t1 - 5i4 and " |
1907 | "20e0 >= 1511 - 4t1 - 5i4) }" }, |
1908 | /* Check that no constraints on i6 are introduced in the gist */ |
1909 | { "[t1, t2] -> { [i4, i5, i6] : exists (e0 = floor((1 + i4)/2), " |
1910 | "e1 = floor((1530 - 4t1 - 5i4)/20), " |
1911 | "e2 = floor((-4t1 - 5i4 + 10*floor((1 + i4)/2))/20), " |
1912 | "e3 = floor((-1 + i4)/2): t2 = 0 and 2e3 = -1 + i4 and " |
1913 | "20e2 >= -19 - 4t1 - 5i4 + 10e0 and 5e2 <= 1 - t1 and " |
1914 | "2e0 <= 1 + i4 and 2e0 >= i4 and " |
1915 | "20e1 <= 1530 - 4t1 - 5i4 and " |
1916 | "20e1 >= 1511 - 4t1 - 5i4 and i4 <= 1 and " |
1917 | "5e1 <= 381 - t1 and 20e2 <= -4t1 - 5i4 + 10e0) }", |
1918 | "[t1, t2] -> { [i4, i5, i6] : exists (e0 = floor((-17 + i4)/2), " |
1919 | "e1 = floor((-t1 + i6)/5): 5e1 = -t1 + i6 and " |
1920 | "2e0 <= -17 + i4 and 2e0 >= -18 + i4 and " |
1921 | "10e0 <= -91 + 5i4 + 4i6 and " |
1922 | "10e0 >= -105 + 5i4 + 4i6) }", |
1923 | "[t1, t2] -> { [i4, i5, i6] : exists (e0 = floor((381 - t1)/5), " |
1924 | "e1 = floor((-1 + i4)/2): t2 = 0 and 2e1 = -1 + i4 and " |
1925 | "i4 <= 1 and 5e0 <= 381 - t1 and 20e0 >= 1511 - 4t1 - 5i4) }" }, |
1926 | { "{ [0, 0, q, p] : -5 <= q <= 5 and p >= 0 }", |
1927 | "{ [a, b, q, p] : b >= 1 + a }", |
1928 | "{ [a, b, q, p] : false }" }, |
1929 | { "[n] -> { [x] : x = n && x mod 32 = 0 }", |
1930 | "[n] -> { [x] : x mod 32 = 0 }", |
1931 | "[n] -> { [x = n] }" }, |
1932 | { "{ [x] : x mod 6 = 0 }", "{ [x] : x mod 3 = 0 }", |
1933 | "{ [x] : x mod 2 = 0 }" }, |
1934 | { "{ [x] : x mod 3200 = 0 }", "{ [x] : x mod 10000 = 0 }", |
1935 | "{ [x] : x mod 128 = 0 }" }, |
1936 | { "{ [x] : x mod 3200 = 0 }", "{ [x] : x mod 10 = 0 }", |
1937 | "{ [x] : x mod 3200 = 0 }" }, |
1938 | { "{ [a, b, c] : a mod 2 = 0 and a = c }", |
1939 | "{ [a, b, c] : b mod 2 = 0 and b = c }", |
1940 | "{ [a, b, c = a] }" }, |
1941 | { "{ [a, b, c] : a mod 6 = 0 and a = c }", |
1942 | "{ [a, b, c] : b mod 2 = 0 and b = c }", |
1943 | "{ [a, b, c = a] : a mod 3 = 0 }" }, |
1944 | { "{ [x] : 0 <= x <= 4 or 6 <= x <= 9 }", |
1945 | "{ [x] : 1 <= x <= 3 or 7 <= x <= 8 }", |
1946 | "{ [x] }" }, |
1947 | { "{ [x,y] : x < 0 and 0 <= y <= 4 or x >= -2 and -x <= y <= 10 + x }", |
1948 | "{ [x,y] : 1 <= y <= 3 }", |
1949 | "{ [x,y] }" }, |
1950 | }; |
1951 | |
1952 | /* Check that isl_set_gist behaves as expected. |
1953 | * |
1954 | * For the test cases in gist_tests, besides checking that the result |
1955 | * is as expected, also check that applying the gist operation does |
1956 | * not modify the input set (an earlier version of isl would do that) and |
1957 | * that the test case is consistent, i.e., that the gist has the same |
1958 | * intersection with the context as the input set. |
1959 | */ |
1960 | static int test_gist(struct isl_ctx *ctx) |
1961 | { |
1962 | int i; |
1963 | const char *str; |
1964 | isl_basic_setisl_basic_map *bset1, *bset2; |
1965 | isl_map *map1, *map2; |
1966 | isl_bool equal; |
1967 | isl_size n_div; |
1968 | |
1969 | for (i = 0; i < ARRAY_SIZE(gist_tests)(sizeof(gist_tests)/sizeof(*gist_tests)); ++i) { |
1970 | isl_bool equal_input, equal_intersection; |
1971 | isl_setisl_map *set1, *set2, *copy, *context; |
1972 | |
1973 | set1 = isl_set_read_from_str(ctx, gist_tests[i].set); |
1974 | context = isl_set_read_from_str(ctx, gist_tests[i].context); |
1975 | copy = isl_set_copy(set1); |
1976 | set1 = isl_set_gist(set1, isl_set_copy(context)); |
1977 | set2 = isl_set_read_from_str(ctx, gist_tests[i].gist); |
1978 | equal = isl_set_is_equal(set1, set2); |
1979 | isl_set_free(set1); |
1980 | set1 = isl_set_read_from_str(ctx, gist_tests[i].set); |
1981 | equal_input = isl_set_is_equal(set1, copy); |
1982 | isl_set_free(copy); |
1983 | set1 = isl_set_intersect(set1, isl_set_copy(context)); |
1984 | set2 = isl_set_intersect(set2, context); |
1985 | equal_intersection = isl_set_is_equal(set1, set2); |
1986 | isl_set_free(set2); |
1987 | isl_set_free(set1); |
1988 | if (equal < 0 || equal_input < 0 || equal_intersection < 0) |
1989 | return -1; |
1990 | if (!equal) |
1991 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect gist result" , "polly/lib/External/isl/isl_test.c", 1992); return -1; } while (0) |
1992 | "incorrect gist result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect gist result" , "polly/lib/External/isl/isl_test.c", 1992); return -1; } while (0); |
1993 | if (!equal_input) |
1994 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "gist modified input" , "polly/lib/External/isl/isl_test.c", 1995); return -1; } while (0) |
1995 | "gist modified input", return -1)do { isl_handle_error(ctx, isl_error_unknown, "gist modified input" , "polly/lib/External/isl/isl_test.c", 1995); return -1; } while (0); |
1996 | if (!equal_input) |
1997 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "inconsistent gist test case" , "polly/lib/External/isl/isl_test.c", 1998); return -1; } while (0) |
1998 | "inconsistent gist test case", return -1)do { isl_handle_error(ctx, isl_error_unknown, "inconsistent gist test case" , "polly/lib/External/isl/isl_test.c", 1998); return -1; } while (0); |
1999 | } |
2000 | |
2001 | if (test_gist_fail(ctx) < 0) |
2002 | return -1; |
2003 | |
2004 | str = "[p0, p2, p3, p5, p6, p10] -> { [] : " |
2005 | "exists (e0 = [(15 + p0 + 15p6 + 15p10)/16], e1 = [(p5)/8], " |
2006 | "e2 = [(p6)/128], e3 = [(8p2 - p5)/128], " |
2007 | "e4 = [(128p3 - p6)/4096]: 8e1 = p5 and 128e2 = p6 and " |
2008 | "128e3 = 8p2 - p5 and 4096e4 = 128p3 - p6 and p2 >= 0 and " |
2009 | "16e0 >= 16 + 16p6 + 15p10 and p2 <= 15 and p3 >= 0 and " |
2010 | "p3 <= 31 and p6 >= 128p3 and p5 >= 8p2 and p10 >= 0 and " |
2011 | "16e0 <= 15 + p0 + 15p6 + 15p10 and 16e0 >= p0 + 15p6 + 15p10 and " |
2012 | "p10 <= 15 and p10 <= -1 + p0 - p6) }"; |
2013 | bset1 = isl_basic_set_read_from_str(ctx, str); |
2014 | str = "[p0, p2, p3, p5, p6, p10] -> { [] : exists (e0 = [(p5)/8], " |
2015 | "e1 = [(p6)/128], e2 = [(8p2 - p5)/128], " |
2016 | "e3 = [(128p3 - p6)/4096]: 8e0 = p5 and 128e1 = p6 and " |
2017 | "128e2 = 8p2 - p5 and 4096e3 = 128p3 - p6 and p5 >= -7 and " |
2018 | "p2 >= 0 and 8p2 <= -1 + p0 and p2 <= 15 and p3 >= 0 and " |
2019 | "p3 <= 31 and 128p3 <= -1 + p0 and p6 >= -127 and " |
2020 | "p5 <= -1 + p0 and p6 <= -1 + p0 and p6 >= 128p3 and " |
2021 | "p0 >= 1 and p5 >= 8p2 and p10 >= 0 and p10 <= 15 ) }"; |
2022 | bset2 = isl_basic_set_read_from_str(ctx, str); |
2023 | bset1 = isl_basic_set_gist(bset1, bset2); |
2024 | assert(bset1 && bset1->n_div == 0)((void) sizeof ((bset1 && bset1->n_div == 0) ? 1 : 0), __extension__ ({ if (bset1 && bset1->n_div == 0) ; else __assert_fail ("bset1 && bset1->n_div == 0" , "polly/lib/External/isl/isl_test.c", 2024, __extension__ __PRETTY_FUNCTION__ ); })); |
2025 | isl_basic_set_free(bset1); |
2026 | |
2027 | /* Check that the integer divisions of the second disjunct |
2028 | * do not spread to the first disjunct. |
2029 | */ |
2030 | str = "[t1] -> { S_0[] -> A[o0] : (exists (e0 = [(-t1 + o0)/16]: " |
2031 | "16e0 = -t1 + o0 and o0 >= 0 and o0 <= 15 and t1 >= 0)) or " |
2032 | "(exists (e0 = [(-1 + t1)/16], " |
2033 | "e1 = [(-16 + t1 - 16e0)/4294967296]: " |
2034 | "4294967296e1 = -16 + t1 - o0 - 16e0 and " |
2035 | "16e0 <= -1 + t1 and 16e0 >= -16 + t1 and o0 >= 0 and " |
2036 | "o0 <= 4294967295 and t1 <= -1)) }"; |
2037 | map1 = isl_map_read_from_str(ctx, str); |
2038 | str = "[t1] -> { S_0[] -> A[o0] : t1 >= 0 and t1 <= 4294967295 }"; |
2039 | map2 = isl_map_read_from_str(ctx, str); |
2040 | map1 = isl_map_gist(map1, map2); |
2041 | if (!map1) |
2042 | return -1; |
2043 | if (map1->n != 1) |
2044 | isl_die(ctx, isl_error_unknown, "expecting single disjunct",do { isl_handle_error(ctx, isl_error_unknown, "expecting single disjunct" , "polly/lib/External/isl/isl_test.c", 2045); isl_map_free(map1 ); return -1; } while (0) |
2045 | isl_map_free(map1); return -1)do { isl_handle_error(ctx, isl_error_unknown, "expecting single disjunct" , "polly/lib/External/isl/isl_test.c", 2045); isl_map_free(map1 ); return -1; } while (0); |
2046 | n_div = isl_basic_map_dim(map1->p[0], isl_dim_div); |
2047 | isl_map_free(map1); |
2048 | if (n_div < 0) |
2049 | return -1; |
2050 | if (n_div != 1) |
2051 | isl_die(ctx, isl_error_unknown, "expecting single div",do { isl_handle_error(ctx, isl_error_unknown, "expecting single div" , "polly/lib/External/isl/isl_test.c", 2052); return -1; } while (0) |
2052 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "expecting single div" , "polly/lib/External/isl/isl_test.c", 2052); return -1; } while (0); |
2053 | |
2054 | if (test_gist_empty(ctx) < 0) |
2055 | return -1; |
2056 | if (test_plain_gist(ctx) < 0) |
2057 | return -1; |
2058 | |
2059 | return 0; |
2060 | } |
2061 | |
2062 | int test_coalesce_set(isl_ctx *ctx, const char *str, int check_one) |
2063 | { |
2064 | isl_setisl_map *set, *set2; |
2065 | int equal; |
2066 | int one; |
2067 | |
2068 | set = isl_set_read_from_str(ctx, str); |
2069 | set = isl_set_coalesce(set); |
2070 | set2 = isl_set_read_from_str(ctx, str); |
2071 | equal = isl_set_is_equal(set, set2); |
2072 | one = set && set->n == 1; |
2073 | isl_set_free(set); |
2074 | isl_set_free(set2); |
2075 | |
2076 | if (equal < 0) |
2077 | return -1; |
2078 | if (!equal) |
2079 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "coalesced set not equal to input" , "polly/lib/External/isl/isl_test.c", 2080); return -1; } while (0) |
2080 | "coalesced set not equal to input", return -1)do { isl_handle_error(ctx, isl_error_unknown, "coalesced set not equal to input" , "polly/lib/External/isl/isl_test.c", 2080); return -1; } while (0); |
2081 | if (check_one && !one) |
2082 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "coalesced set should not be a union" , "polly/lib/External/isl/isl_test.c", 2083); return -1; } while (0) |
2083 | "coalesced set should not be a union", return -1)do { isl_handle_error(ctx, isl_error_unknown, "coalesced set should not be a union" , "polly/lib/External/isl/isl_test.c", 2083); return -1; } while (0); |
2084 | |
2085 | return 0; |
2086 | } |
2087 | |
2088 | /* Inputs for coalescing tests with unbounded wrapping. |
2089 | * "str" is a string representation of the input set. |
2090 | * "single_disjunct" is set if we expect the result to consist of |
2091 | * a single disjunct. |
2092 | */ |
2093 | struct { |
2094 | int single_disjunct; |
2095 | const char *str; |
2096 | } coalesce_unbounded_tests[] = { |
2097 | { 1, "{ [x,y,z] : y + 2 >= 0 and x - y + 1 >= 0 and " |
2098 | "-x - y + 1 >= 0 and -3 <= z <= 3;" |
2099 | "[x,y,z] : -x+z + 20 >= 0 and -x-z + 20 >= 0 and " |
2100 | "x-z + 20 >= 0 and x+z + 20 >= 0 and " |
2101 | "-10 <= y <= 0}" }, |
2102 | { 1, "{ [x,y] : 0 <= x,y <= 10; [5,y]: 4 <= y <= 11 }" }, |
2103 | { 1, "{ [x,0,0] : -5 <= x <= 5; [0,y,1] : -5 <= y <= 5 }" }, |
2104 | { 1, "{ [x,y] : 0 <= x <= 10 and 0 >= y >= -1 and x+y >= 0; [0,1] }" }, |
2105 | { 1, "{ [x,y] : (0 <= x,y <= 4) or (2 <= x,y <= 5 and x + y <= 9) }" }, |
2106 | { 0, "{ [x, y, z] : 0 <= x,y,z <= 100 and 0 < z <= 2 + 2x + 2y; " |
2107 | "[x, y, 0] : x,y <= 100 and y <= 9 + 11x and x <= 9 + 11y }" }, |
2108 | { 1, "{ [0:1, 0:1]; [0, 2:3] }" }, |
2109 | { 1, "{ [0:1, 0:1]; [0, 2:3]; [1, -2:-1] }" }, |
2110 | { 1, "{ [0:3, 0:1]; [1:2, 2:5] }" }, |
2111 | { 1, "{ [0:3, 0:1]; [0:2, 2:5] }" }, |
2112 | { 1, "{ [0:3, 0:1]; [1:3, 2:5] }" }, |
2113 | { 0, "{ [0:3, 0:1]; [1:4, 2:5] }" }, |
2114 | { 0, "{ [0:3, 0:1]; [1:5, 2:5] }" }, |
2115 | }; |
2116 | |
2117 | /* Test the functionality of isl_set_coalesce with the bounded wrapping |
2118 | * option turned off. |
2119 | */ |
2120 | int test_coalesce_unbounded_wrapping(isl_ctx *ctx) |
2121 | { |
2122 | int i; |
2123 | int r = 0; |
2124 | int bounded; |
2125 | |
2126 | bounded = isl_options_get_coalesce_bounded_wrapping(ctx); |
2127 | isl_options_set_coalesce_bounded_wrapping(ctx, 0); |
2128 | |
2129 | for (i = 0; i < ARRAY_SIZE(coalesce_unbounded_tests)(sizeof(coalesce_unbounded_tests)/sizeof(*coalesce_unbounded_tests )); ++i) { |
2130 | const char *str = coalesce_unbounded_tests[i].str; |
2131 | int check_one = coalesce_unbounded_tests[i].single_disjunct; |
2132 | if (test_coalesce_set(ctx, str, check_one) >= 0) |
2133 | continue; |
2134 | r = -1; |
2135 | break; |
2136 | } |
2137 | |
2138 | isl_options_set_coalesce_bounded_wrapping(ctx, bounded); |
2139 | |
2140 | return r; |
2141 | } |
2142 | |
2143 | /* Inputs for coalescing tests. |
2144 | * "str" is a string representation of the input set. |
2145 | * "single_disjunct" is set if we expect the result to consist of |
2146 | * a single disjunct. |
2147 | */ |
2148 | struct { |
2149 | int single_disjunct; |
2150 | const char *str; |
2151 | } coalesce_tests[] = { |
2152 | { 1, "{[x,y]: x >= 0 & x <= 10 & y >= 0 & y <= 10 or " |
2153 | "y >= x & x >= 2 & 5 >= y }" }, |
2154 | { 1, "{[x,y]: y >= 0 & 2x + y <= 30 & y <= 10 & x >= 0 or " |
2155 | "x + y >= 10 & y <= x & x + y <= 20 & y >= 0}" }, |
2156 | { 0, "{[x,y]: y >= 0 & 2x + y <= 30 & y <= 10 & x >= 0 or " |
2157 | "x + y >= 10 & y <= x & x + y <= 19 & y >= 0}" }, |
2158 | { 1, "{[x,y]: y >= 0 & x <= 5 & y <= x or " |
2159 | "y >= 0 & x >= 6 & x <= 10 & y <= x}" }, |
2160 | { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or " |
2161 | "y >= 0 & x >= 7 & x <= 10 & y <= x}" }, |
2162 | { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or " |
2163 | "y >= 0 & x >= 6 & x <= 10 & y + 1 <= x}" }, |
2164 | { 1, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 6 & y <= 6}" }, |
2165 | { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 7 & y <= 6}" }, |
2166 | { 1, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 6 & y <= 5}" }, |
2167 | { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 6 & y <= 7}" }, |
2168 | { 1, "[n] -> { [i] : i = 1 and n >= 2 or 2 <= i and i <= n }" }, |
2169 | { 0, "{[x,y] : x >= 0 and y >= 0 or 0 <= y and y <= 5 and x = -1}" }, |
2170 | { 1, "[n] -> { [i] : 1 <= i and i <= n - 1 or 2 <= i and i <= n }" }, |
2171 | { 0, "[n] -> { [[i0] -> [o0]] : exists (e0 = [(i0)/4], e1 = [(o0)/4], " |
2172 | "e2 = [(n)/2], e3 = [(-2 + i0)/4], e4 = [(-2 + o0)/4], " |
2173 | "e5 = [(-2n + i0)/4]: 2e2 = n and 4e3 = -2 + i0 and " |
2174 | "4e4 = -2 + o0 and i0 >= 8 + 2n and o0 >= 2 + i0 and " |
2175 | "o0 <= 56 + 2n and o0 <= -12 + 4n and i0 <= 57 + 2n and " |
2176 | "i0 <= -11 + 4n and o0 >= 6 + 2n and 4e0 <= i0 and " |
2177 | "4e0 >= -3 + i0 and 4e1 <= o0 and 4e1 >= -3 + o0 and " |
2178 | "4e5 <= -2n + i0 and 4e5 >= -3 - 2n + i0);" |
2179 | "[[i0] -> [o0]] : exists (e0 = [(i0)/4], e1 = [(o0)/4], " |
2180 | "e2 = [(n)/2], e3 = [(-2 + i0)/4], e4 = [(-2 + o0)/4], " |
2181 | "e5 = [(-2n + i0)/4]: 2e2 = n and 4e3 = -2 + i0 and " |
2182 | "4e4 = -2 + o0 and 2e0 >= 3 + n and e0 <= -4 + n and " |
2183 | "2e0 <= 27 + n and e1 <= -4 + n and 2e1 <= 27 + n and " |
2184 | "2e1 >= 2 + n and e1 >= 1 + e0 and i0 >= 7 + 2n and " |
2185 | "i0 <= -11 + 4n and i0 <= 57 + 2n and 4e0 <= -2 + i0 and " |
2186 | "4e0 >= -3 + i0 and o0 >= 6 + 2n and o0 <= -11 + 4n and " |
2187 | "o0 <= 57 + 2n and 4e1 <= -2 + o0 and 4e1 >= -3 + o0 and " |
2188 | "4e5 <= -2n + i0 and 4e5 >= -3 - 2n + i0 ) }" }, |
2189 | { 0, "[n, m] -> { [o0, o2, o3] : (o3 = 1 and o0 >= 1 + m and " |
2190 | "o0 <= n + m and o2 <= m and o0 >= 2 + n and o2 >= 3) or " |
2191 | "(o0 >= 2 + n and o0 >= 1 + m and o0 <= n + m and n >= 1 and " |
2192 | "o3 <= -1 + o2 and o3 >= 1 - m + o2 and o3 >= 2 and o3 <= n) }" }, |
2193 | { 0, "[M, N] -> { [[i0, i1, i2, i3, i4, i5, i6] -> " |
2194 | "[o0, o1, o2, o3, o4, o5, o6]] : " |
2195 | "(o6 <= -4 + 2M - 2N + i0 + i1 - i2 + i6 - o0 - o1 + o2 and " |
2196 | "o3 <= -2 + i3 and o6 >= 2 + i0 + i3 + i6 - o0 - o3 and " |
2197 | "o6 >= 2 - M + N + i3 + i4 + i6 - o3 - o4 and o0 <= -1 + i0 and " |
2198 | "o4 >= 4 - 3M + 3N - i0 - i1 + i2 + 2i3 + i4 + o0 + o1 - o2 - 2o3 " |
2199 | "and o6 <= -3 + 2M - 2N + i3 + i4 - i5 + i6 - o3 - o4 + o5 and " |
2200 | "2o6 <= -5 + 5M - 5N + 2i0 + i1 - i2 - i5 + 2i6 - 2o0 - o1 + o2 + o5 " |
2201 | "and o6 >= 2i0 + i1 + i6 - 2o0 - o1 and " |
2202 | "3o6 <= -5 + 4M - 4N + 2i0 + i1 - i2 + 2i3 + i4 - i5 + 3i6 " |
2203 | "- 2o0 - o1 + o2 - 2o3 - o4 + o5) or " |
2204 | "(N >= 2 and o3 <= -1 + i3 and o0 <= -1 + i0 and " |
2205 | "o6 >= i3 + i6 - o3 and M >= 0 and " |
2206 | "2o6 >= 1 + i0 + i3 + 2i6 - o0 - o3 and " |
2207 | "o6 >= 1 - M + i0 + i6 - o0 and N >= 2M and o6 >= i0 + i6 - o0) }" }, |
2208 | { 0, "[M, N] -> { [o0] : (o0 = 0 and M >= 1 and N >= 2) or " |
2209 | "(o0 = 0 and M >= 1 and N >= 2M and N >= 2 + M) or " |
2210 | "(o0 = 0 and M >= 2 and N >= 3) or " |
2211 | "(M = 0 and o0 = 0 and N >= 3) }" }, |
2212 | { 0, "{ [i0, i1, i2, i3] : (i1 = 10i0 and i0 >= 1 and 10i0 <= 100 and " |
2213 | "i3 <= 9 + 10 i2 and i3 >= 1 + 10i2 and i3 >= 0) or " |
2214 | "(i1 <= 9 + 10i0 and i1 >= 1 + 10i0 and i2 >= 0 and " |
2215 | "i0 >= 0 and i1 <= 100 and i3 <= 9 + 10i2 and i3 >= 1 + 10i2) }" }, |
2216 | { 0, "[M] -> { [i1] : (i1 >= 2 and i1 <= M) or (i1 = M and M >= 1) }" }, |
2217 | { 0, "{[x,y] : x,y >= 0; [x,y] : 10 <= x <= 20 and y >= -1 }" }, |
2218 | { 1, "{ [x, y] : (x >= 1 and y >= 1 and x <= 2 and y <= 2) or " |
2219 | "(y = 3 and x = 1) }" }, |
2220 | { 1, "[M] -> { [i0, i1, i2, i3, i4] : (i1 >= 3 and i4 >= 2 + i2 and " |
2221 | "i2 >= 2 and i0 >= 2 and i3 >= 1 + i2 and i0 <= M and " |
2222 | "i1 <= M and i3 <= M and i4 <= M) or " |
2223 | "(i1 >= 2 and i4 >= 1 + i2 and i2 >= 2 and i0 >= 2 and " |
2224 | "i3 >= 1 + i2 and i0 <= M and i1 <= -1 + M and i3 <= M and " |
2225 | "i4 <= -1 + M) }" }, |
2226 | { 1, "{ [x, y] : (x >= 0 and y >= 0 and x <= 10 and y <= 10) or " |
2227 | "(x >= 1 and y >= 1 and x <= 11 and y <= 11) }" }, |
2228 | { 0, "{[x,0] : x >= 0; [x,1] : x <= 20}" }, |
2229 | { 1, "{ [x, 1 - x] : 0 <= x <= 1; [0,0] }" }, |
2230 | { 1, "{ [0,0]; [i,i] : 1 <= i <= 10 }" }, |
2231 | { 0, "{ [0,0]; [i,j] : 1 <= i,j <= 10 }" }, |
2232 | { 1, "{ [0,0]; [i,2i] : 1 <= i <= 10 }" }, |
2233 | { 0, "{ [0,0]; [i,2i] : 2 <= i <= 10 }" }, |
2234 | { 0, "{ [1,0]; [i,2i] : 1 <= i <= 10 }" }, |
2235 | { 0, "{ [0,1]; [i,2i] : 1 <= i <= 10 }" }, |
2236 | { 0, "{ [a, b] : exists e : 2e = a and " |
2237 | "a >= 0 and (a <= 3 or (b <= 0 and b >= -4 + a)) }" }, |
2238 | { 0, "{ [i, j, i', j'] : i <= 2 and j <= 2 and " |
2239 | "j' >= -1 + 2i + j - 2i' and i' <= -1 + i and " |
2240 | "j >= 1 and j' <= i + j - i' and i >= 1; " |
2241 | "[1, 1, 1, 1] }" }, |
2242 | { 1, "{ [i,j] : exists a,b : i = 2a and j = 3b; " |
2243 | "[i,j] : exists a : j = 3a }" }, |
2244 | { 1, "{ [a, b, c] : (c <= 7 - b and b <= 1 and b >= 0 and " |
2245 | "c >= 3 + b and b <= 3 + 8a and b >= -26 + 8a and " |
2246 | "a >= 3) or " |
2247 | "(b <= 1 and c <= 7 and b >= 0 and c >= 4 + b and " |
2248 | "b <= 3 + 8a and b >= -26 + 8a and a >= 3) }" }, |
2249 | { 1, "{ [a, 0, c] : c >= 1 and c <= 29 and c >= -1 + 8a and " |
2250 | "c <= 6 + 8a and a >= 3; " |
2251 | "[a, -1, c] : c >= 1 and c <= 30 and c >= 8a and " |
2252 | "c <= 7 + 8a and a >= 3 and a <= 4 }" }, |
2253 | { 1, "{ [x,y] : 0 <= x <= 2 and y >= 0 and x + 2y <= 4; " |
2254 | "[x,0] : 3 <= x <= 4 }" }, |
2255 | { 1, "{ [x,y] : 0 <= x <= 3 and y >= 0 and x + 3y <= 6; " |
2256 | "[x,0] : 4 <= x <= 5 }" }, |
2257 | { 0, "{ [x,y] : 0 <= x <= 2 and y >= 0 and x + 2y <= 4; " |
2258 | "[x,0] : 3 <= x <= 5 }" }, |
2259 | { 0, "{ [x,y] : 0 <= x <= 2 and y >= 0 and x + y <= 4; " |
2260 | "[x,0] : 3 <= x <= 4 }" }, |
2261 | { 1, "{ [i0, i1] : i0 <= 122 and i0 >= 1 and 128i1 >= -249 + i0 and " |
2262 | "i1 <= 0; " |
2263 | "[i0, 0] : i0 >= 123 and i0 <= 124 }" }, |
2264 | { 1, "{ [0,0]; [1,1] }" }, |
2265 | { 1, "[n] -> { [k] : 16k <= -1 + n and k >= 1; [0] : n >= 2 }" }, |
2266 | { 1, "{ [k, ii, k - ii] : ii >= -6 + k and ii <= 6 and ii >= 1 and " |
2267 | "ii <= k;" |
2268 | "[k, 0, k] : k <= 6 and k >= 1 }" }, |
2269 | { 1, "{ [i,j] : i = 4 j and 0 <= i <= 100;" |
2270 | "[i,j] : 1 <= i <= 100 and i >= 4j + 1 and i <= 4j + 2 }" }, |
2271 | { 1, "{ [x,y] : x % 2 = 0 and y % 2 = 0; [x,x] : x % 2 = 0 }" }, |
2272 | { 1, "[n] -> { [1] : n >= 0;" |
2273 | "[x] : exists (e0 = floor((x)/2): x >= 2 and " |
2274 | "2e0 >= -1 + x and 2e0 <= x and 2e0 <= n) }" }, |
2275 | { 1, "[n] -> { [x, y] : exists (e0 = floor((x)/2), e1 = floor((y)/3): " |
2276 | "3e1 = y and x >= 2 and 2e0 >= -1 + x and " |
2277 | "2e0 <= x and 2e0 <= n);" |
2278 | "[1, y] : exists (e0 = floor((y)/3): 3e0 = y and " |
2279 | "n >= 0) }" }, |
2280 | { 1, "[t1] -> { [i0] : (exists (e0 = floor((63t1)/64): " |
2281 | "128e0 >= -134 + 127t1 and t1 >= 2 and " |
2282 | "64e0 <= 63t1 and 64e0 >= -63 + 63t1)) or " |
2283 | "t1 = 1 }" }, |
2284 | { 1, "{ [i, i] : exists (e0 = floor((1 + 2i)/3): 3e0 <= 2i and " |
2285 | "3e0 >= -1 + 2i and i <= 9 and i >= 1);" |
2286 | "[0, 0] }" }, |
2287 | { 1, "{ [t1] : exists (e0 = floor((-11 + t1)/2): 2e0 = -11 + t1 and " |
2288 | "t1 >= 13 and t1 <= 16);" |
2289 | "[t1] : t1 <= 15 and t1 >= 12 }" }, |
2290 | { 1, "{ [x,y] : x = 3y and 0 <= y <= 2; [-3,-1] }" }, |
2291 | { 1, "{ [x,y] : 2x = 3y and 0 <= y <= 4; [-3,-2] }" }, |
2292 | { 0, "{ [x,y] : 2x = 3y and 0 <= y <= 4; [-2,-2] }" }, |
2293 | { 0, "{ [x,y] : 2x = 3y and 0 <= y <= 4; [-3,-1] }" }, |
2294 | { 1, "{ [i] : exists j : i = 4 j and 0 <= i <= 100;" |
2295 | "[i] : exists j : 1 <= i <= 100 and i >= 4j + 1 and " |
2296 | "i <= 4j + 2 }" }, |
2297 | { 1, "{ [c0] : (exists (e0 : c0 - 1 <= 3e0 <= c0)) or " |
2298 | "(exists (e0 : 3e0 = -2 + c0)) }" }, |
2299 | { 0, "[n, b0, t0] -> " |
2300 | "{ [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] : " |
2301 | "(exists (e0 = floor((-32b0 + i4)/1048576), " |
2302 | "e1 = floor((i8)/32): 1048576e0 = -32b0 + i4 and 32e1 = i8 and " |
2303 | "n <= 2147483647 and b0 <= 32767 and b0 >= 0 and " |
2304 | "32b0 <= -2 + n and t0 <= 31 and t0 >= 0 and i0 >= 8 + n and " |
2305 | "3i4 <= -96 + 3t0 + i0 and 3i4 >= -95 - n + 3t0 + i0 and " |
2306 | "i8 >= -157 + i0 - 4i4 and i8 >= 0 and " |
2307 | "i8 <= -33 + i0 - 4i4 and 3i8 <= -91 + 4n - i0)) or " |
2308 | "(exists (e0 = floor((-32b0 + i4)/1048576), " |
2309 | "e1 = floor((i8)/32): 1048576e0 = -32b0 + i4 and 32e1 = i8 and " |
2310 | "n <= 2147483647 and b0 <= 32767 and b0 >= 0 and " |
2311 | "32b0 <= -2 + n and t0 <= 31 and t0 >= 0 and i0 <= 7 + n and " |
2312 | "4i4 <= -3 + i0 and 3i4 <= -96 + 3t0 + i0 and " |
2313 | "3i4 >= -95 - n + 3t0 + i0 and i8 >= -157 + i0 - 4i4 and " |
2314 | "i8 >= 0 and i8 <= -4 + i0 - 3i4 and i8 <= -41 + i0));" |
2315 | "[i0, i1, i2, i3, 0, i5, i6, i7, i8, i9, i10, i11, i12] : " |
2316 | "(exists (e0 = floor((i8)/32): b0 = 0 and 32e0 = i8 and " |
2317 | "n <= 2147483647 and t0 <= 31 and t0 >= 0 and i0 >= 11 and " |
2318 | "i0 >= 96 - 3t0 and i0 <= 95 + n - 3t0 and i0 <= 7 + n and " |
2319 | "i8 >= -40 + i0 and i8 <= -10 + i0)) }" }, |
2320 | { 0, "{ [i0, i1, i2] : " |
2321 | "(exists (e0, e1 = floor((i0)/32), e2 = floor((i1)/32): " |
2322 | "32e1 = i0 and 32e2 = i1 and i1 >= -31 + i0 and " |
2323 | "i1 <= 31 + i0 and i2 >= -30 + i0 and i2 >= -30 + i1 and " |
2324 | "32e0 >= -30 + i0 and 32e0 >= -30 + i1 and " |
2325 | "32e0 >= -31 + i2 and 32e0 <= 30 + i2 and 32e0 <= 31 + i1 and " |
2326 | "32e0 <= 31 + i0)) or " |
2327 | "i0 >= 0 }" }, |
2328 | { 1, "{ [a, b, c] : 2b = 1 + a and 2c = 2 + a; [0, 0, 0] }" }, |
2329 | { 1, "{ [a, a, b, c] : 32*floor((a)/32) = a and 2*floor((b)/2) = b and " |
2330 | "2*floor((c)/2) = c and 0 <= a <= 192;" |
2331 | "[224, 224, b, c] : 2*floor((b)/2) = b and 2*floor((c)/2) = c }" |
2332 | }, |
2333 | { 1, "[n] -> { [a,b] : (exists e : 1 <= a <= 7e and 9e <= b <= n) or " |
2334 | "(0 <= a <= b <= n) }" }, |
2335 | { 1, "{ [a, b] : 0 <= a <= 2 and b >= 0 and " |
2336 | "((0 < b <= 13) or (2*floor((a + b)/2) >= -5 + a + 2b)) }" }, |
2337 | { 1, "{ [a] : (2 <= a <= 5) or (a mod 2 = 1 and 1 <= a <= 5) }" }, |
2338 | { 1, "{ [a, b, c] : (b = -1 + a and 0 < a <= 3 and " |
2339 | "9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or " |
2340 | "(exists (e0 = floor((-16 + 2c)/9): a = 4 and " |
2341 | "b = 3 and 9e0 <= -19 + 2c)) }" }, |
2342 | { 1, "{ [a, b, c] : (b = -1 + a and 0 < a <= 3 and " |
2343 | "9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or " |
2344 | "(a = 4 and b = 3 and " |
2345 | "9*floor((-16 + 2c)/9) <= -19 + 2c) }" }, |
2346 | { 0, "{ [a, b, c] : (b <= 2 and b <= -2 + a) or " |
2347 | "(b = -1 + a and 0 < a <= 3 and " |
2348 | "9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or " |
2349 | "(exists (e0 = floor((-16 + 2c)/9): a = 4 and " |
2350 | "b = 3 and 9e0 <= -19 + 2c)) }" }, |
2351 | { 1, "{ [y, x] : (x - y) mod 3 = 2 and 2 <= y <= 200 and 0 <= x <= 2;" |
2352 | "[1, 0] }" }, |
2353 | { 1, "{ [x, y] : (x - y) mod 3 = 2 and 2 <= y <= 200 and 0 <= x <= 2;" |
2354 | "[0, 1] }" }, |
2355 | { 1, "{ [1, y] : -1 <= y <= 1; [x, -x] : 0 <= x <= 1 }" }, |
2356 | { 1, "{ [1, y] : 0 <= y <= 1; [x, -x] : 0 <= x <= 1 }" }, |
2357 | { 1, "{ [x, y] : 0 <= x <= 10 and x - 4*floor(x/4) <= 1 and y <= 0; " |
2358 | "[x, y] : 0 <= x <= 10 and x - 4*floor(x/4) > 1 and y <= 0; " |
2359 | "[x, y] : 0 <= x <= 10 and x - 5*floor(x/5) <= 1 and 0 < y; " |
2360 | "[x, y] : 0 <= x <= 10 and x - 5*floor(x/5) > 1 and 0 < y }" }, |
2361 | { 1, "{ [x, 0] : 0 <= x <= 10 and x mod 2 = 0; " |
2362 | "[x, 0] : 0 <= x <= 10 and x mod 2 = 1; " |
2363 | "[x, y] : 0 <= x <= 10 and 1 <= y <= 10 }" }, |
2364 | { 1, "{ [a] : a <= 8 and " |
2365 | "(a mod 10 = 7 or a mod 10 = 8 or a mod 10 = 9) }" }, |
2366 | { 1, "{ [x, y] : 2y = -x and x <= 0 or " |
2367 | "x <= -1 and 2y <= -x - 1 and 2y >= x - 1 }" }, |
2368 | { 0, "{ [x, y] : 2y = -x and x <= 0 or " |
2369 | "x <= -2 and 2y <= -x - 1 and 2y >= x - 1 }" }, |
2370 | { 1, "{ [a] : (a <= 0 and 3*floor((a)/3) = a) or " |
2371 | "(a < 0 and 3*floor((a)/3) < a) }" }, |
2372 | { 1, "{ [a] : (a <= 0 and 3*floor((a)/3) = a) or " |
2373 | "(a < -1 and 3*floor((a)/3) < a) }" }, |
2374 | { 1, "{ [a, b] : a <= 1024 and b >= 0 and " |
2375 | "((-31 - a + b <= 32*floor((-1 - a)/32) <= -33 + b and " |
2376 | "32*floor((-1 - a)/32) <= -16 + b + 16*floor((-1 - a)/16))" |
2377 | "or (2 <= a <= 15 and b < a)) }" }, |
2378 | { 1, "{ [a] : a > 0 and ((16*floor((a)/16) < a and " |
2379 | "32*floor((a)/32) < a) or a <= 15) }" }, |
2380 | { 1, "{ [a, b, c, d] : (-a + d) mod 64 = 0 and a <= 8 and b <= 1 and " |
2381 | "10 - a <= c <= 3 and d >= 5 and 9 - 64b <= d <= 70;" |
2382 | "[a, b = 1, c, d] : (-a + d) mod 64 = 0 and a <= 8 and c >= 4 and " |
2383 | "10 - a <= c <= 5 and 5 <= d <= 73 - c }" }, |
2384 | { 1, "[n, m] -> { S_0[i] : (-n + i) mod 3 = 0 and m >= 3 + n and " |
2385 | "i >= n and 3*floor((2 + n + 2m)/3) <= n + 3m - i; " |
2386 | "S_0[n] : n <= m <= 2 + n }" }, |
2387 | { 1, "{ [a, b] : exists (e0: 0 <= a <= 1 and b >= 0 and " |
2388 | "2e0 >= -5 + a + 2b and 2e0 >= -1 + a + b and " |
2389 | "2e0 <= a + b); " |
2390 | "[a, b] : exists (e0: 0 <= a <= 1 and 2e0 >= -5 + a + 2b and " |
2391 | "2e0 >= -1 - a + b and 2e0 <= -a + b and " |
2392 | "2e0 < -a + 2b) }" }, |
2393 | { 1, "{ [i, j, i - 8j] : 8 <= i <= 63 and -7 + i <= 8j <= i; " |
2394 | "[i, 0, i] : 0 <= i <= 7 }" }, |
2395 | { 1, "{ [a, b] : a >= 0 and 0 <= b <= 1 - a; [1, 1] }" }, |
2396 | { 0, "{ [a, b] : a >= 0 and 0 <= b <= 1 - a; [0, 2] }" }, |
2397 | { 0, "{ [a, b] : a >= 0 and 0 <= b <= 1 - a; [-1, 3] }" }, |
2398 | { 1, "{ [a, b] : a, b >= 0 and a + 2b <= 2; [1, 1] }" }, |
2399 | { 0, "{ [a, b] : a, b >= 0 and a + 2b <= 2; [2, 1] }" }, |
2400 | { 0, "{ [a, c] : (2 + a) mod 4 = 0 or " |
2401 | "(c = 4 + a and 4 * floor((a)/4) = a and a >= 0 and a <= 4) or " |
2402 | "(c = 3 + a and 4 * floor((-1 + a)/4) = -1 + a and " |
2403 | "a > 0 and a <= 5) }" }, |
2404 | { 1, "{ [1, 0, 0]; [a, b, c] : -1 <= -a < b <= 0 and 2c > b }" }, |
2405 | { 0, "{ [j, a, l] : a mod 2 = 0 and j <= 29 and a >= 2 and " |
2406 | "2a <= -5 + j and 32j + 2a + 2 <= 4l < 33j; " |
2407 | "[j, 0, l] : 4 <= j <= 29 and -3 + 33j <= 4l <= 33j }" }, |
2408 | { 0, "{ [0:1, 0:1]; [0, 2:3] }" }, |
2409 | { 1, "{ [a] : (a = 0 or ((1 + a) mod 2 = 0 and 0 < a <= 15) or " |
2410 | "((a) mod 2 = 0 and 0 < a <= 15)) }" }, |
2411 | { 1, "{ rat: [0:2]; rat: [1:3] }" }, |
2412 | }; |
2413 | |
2414 | /* A specialized coalescing test case that would result |
2415 | * in a segmentation fault or a failed assertion in earlier versions of isl. |
2416 | */ |
2417 | static int test_coalesce_special(struct isl_ctx *ctx) |
2418 | { |
2419 | const char *str; |
2420 | isl_map *map1, *map2; |
2421 | |
2422 | str = "[y] -> { [S_L220_OUT[] -> T7[]] -> " |
2423 | "[[S_L309_IN[] -> T11[]] -> ce_imag2[1, o1]] : " |
2424 | "(y = 201 and o1 <= 239 and o1 >= 212) or " |
2425 | "(exists (e0 = [(y)/3]: 3e0 = y and y <= 198 and y >= 3 and " |
2426 | "o1 <= 239 and o1 >= 212)) or " |
2427 | "(exists (e0 = [(y)/3]: 3e0 = y and y <= 201 and y >= 3 and " |
2428 | "o1 <= 241 and o1 >= 240));" |
2429 | "[S_L220_OUT[] -> T7[]] -> " |
2430 | "[[S_L309_IN[] -> T11[]] -> ce_imag2[0, o1]] : " |
2431 | "(y = 2 and o1 <= 241 and o1 >= 212) or " |
2432 | "(exists (e0 = [(-2 + y)/3]: 3e0 = -2 + y and y <= 200 and " |
2433 | "y >= 5 and o1 <= 241 and o1 >= 212)) }"; |
2434 | map1 = isl_map_read_from_str(ctx, str); |
2435 | map1 = isl_map_align_divs_internal(map1); |
2436 | map1 = isl_map_coalesce(map1); |
2437 | str = "[y] -> { [S_L220_OUT[] -> T7[]] -> " |
2438 | "[[S_L309_IN[] -> T11[]] -> ce_imag2[o0, o1]] : " |
2439 | "exists (e0 = [(-1 - y + o0)/3]: 3e0 = -1 - y + o0 and " |
2440 | "y <= 201 and o0 <= 2 and o1 >= 212 and o1 <= 241 and " |
2441 | "o0 >= 3 - y and o0 <= -2 + y and o0 >= 0) }"; |
2442 | map2 = isl_map_read_from_str(ctx, str); |
2443 | map2 = isl_map_union(map2, map1); |
2444 | map2 = isl_map_align_divs_internal(map2); |
2445 | map2 = isl_map_coalesce(map2); |
2446 | isl_map_free(map2); |
2447 | if (!map2) |
2448 | return -1; |
2449 | |
2450 | return 0; |
2451 | } |
2452 | |
2453 | /* Check that the union of the basic sets described by "str1" and "str2" |
2454 | * can be coalesced and that the result is equal to the union. |
2455 | * The explicit call to isl_basic_set_union prevents the implicit |
2456 | * equality constraints in the basic maps from being detected prior |
2457 | * to the call to isl_set_coalesce, at least at the point |
2458 | * where this function was introduced. |
2459 | */ |
2460 | static isl_stat test_coalesce_union(isl_ctx *ctx, const char *str1, |
2461 | const char *str2) |
2462 | { |
2463 | isl_basic_setisl_basic_map *bset1, *bset2; |
2464 | isl_setisl_map *set, *set2; |
2465 | isl_bool equal; |
2466 | |
2467 | bset1 = isl_basic_set_read_from_str(ctx, str1); |
2468 | bset2 = isl_basic_set_read_from_str(ctx, str2); |
2469 | set = isl_basic_set_union(bset1, bset2); |
2470 | set = isl_set_coalesce(set); |
2471 | |
2472 | bset1 = isl_basic_set_read_from_str(ctx, str1); |
2473 | bset2 = isl_basic_set_read_from_str(ctx, str2); |
2474 | set2 = isl_basic_set_union(bset1, bset2); |
2475 | |
2476 | equal = isl_set_is_equal(set, set2); |
2477 | isl_set_free(set); |
2478 | isl_set_free(set2); |
2479 | |
2480 | if (equal < 0) |
2481 | return isl_stat_error; |
2482 | if (!equal) |
2483 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "coalesced set not equal to input" , "polly/lib/External/isl/isl_test.c", 2485); return isl_stat_error ; } while (0) |
2484 | "coalesced set not equal to input",do { isl_handle_error(ctx, isl_error_unknown, "coalesced set not equal to input" , "polly/lib/External/isl/isl_test.c", 2485); return isl_stat_error ; } while (0) |
2485 | return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "coalesced set not equal to input" , "polly/lib/External/isl/isl_test.c", 2485); return isl_stat_error ; } while (0); |
2486 | |
2487 | return isl_stat_non_null(set); |
2488 | } |
2489 | |
2490 | /* A specialized coalescing test case that would result in an assertion |
2491 | * in an earlier version of isl. Use test_coalesce_union with |
2492 | * an explicit call to isl_basic_set_union to prevent the implicit |
2493 | * equality constraints in the first basic map from being detected prior |
2494 | * to the call to isl_set_coalesce, at least at the point |
2495 | * where this test case was introduced. |
2496 | */ |
2497 | static isl_stat test_coalesce_special2(struct isl_ctx *ctx) |
2498 | { |
2499 | const char *str1; |
2500 | const char *str2; |
2501 | |
2502 | str1 = "{ [x, y] : x, y >= 0 and x + 2y <= 1 and 2x + y <= 1 }"; |
2503 | str2 = "{ [x,0] : -1 <= x <= 1 and x mod 2 = 1 }"; |
2504 | return test_coalesce_union(ctx, str1, str2); |
2505 | } |
2506 | |
2507 | /* Check that calling isl_set_coalesce does not leave other sets |
2508 | * that may share some information with the input to isl_set_coalesce |
2509 | * in an inconsistent state. |
2510 | * In particular, older versions of isl would modify all copies |
2511 | * of the basic sets in the isl_set_coalesce input in a way |
2512 | * that could leave them in an inconsistent state. |
2513 | * The result of printing any other set containing one of these |
2514 | * basic sets would then result in an invalid set description. |
2515 | */ |
2516 | static int test_coalesce_special3(isl_ctx *ctx) |
2517 | { |
2518 | const char *str; |
2519 | char *s; |
2520 | isl_setisl_map *set1, *set2; |
2521 | isl_printer *p; |
2522 | |
2523 | set1 = isl_set_read_from_str(ctx, "{ [0, 0, 0] }"); |
2524 | str = "{ [a, b, a + b] : a >= 0 and b >= 0 and 0 < a + b }"; |
2525 | set2 = isl_set_read_from_str(ctx, str); |
2526 | set1 = isl_set_union(set1, isl_set_copy(set2)); |
2527 | set1 = isl_set_coalesce(set1); |
2528 | isl_set_free(set1); |
2529 | |
2530 | p = isl_printer_to_str(ctx); |
2531 | p = isl_printer_print_set(p, set2); |
2532 | isl_set_free(set2); |
2533 | s = isl_printer_get_str(p); |
2534 | isl_printer_free(p); |
2535 | set1 = isl_set_read_from_str(ctx, s); |
2536 | free(s); |
2537 | isl_set_free(set1); |
2538 | |
2539 | if (!set1) |
2540 | return -1; |
2541 | |
2542 | return 0; |
2543 | } |
2544 | |
2545 | /* Check that calling isl_set_coalesce on the intersection of |
2546 | * the sets described by "s1" and "s2" does not leave other sets |
2547 | * that may share some information with the input to isl_set_coalesce |
2548 | * in an inconsistent state. |
2549 | * In particular, when isl_set_coalesce detects equality constraints, |
2550 | * it does not immediately perform Gaussian elimination on them, |
2551 | * but then it needs to ensure that it is performed at some point. |
2552 | * The input set has implicit equality constraints in the first disjunct. |
2553 | * It is constructed as an intersection, because otherwise |
2554 | * those equality constraints would already be detected during parsing. |
2555 | */ |
2556 | static isl_stat test_coalesce_intersection(isl_ctx *ctx, |
2557 | const char *s1, const char *s2) |
2558 | { |
2559 | isl_setisl_map *set1, *set2; |
2560 | |
2561 | set1 = isl_set_read_from_str(ctx, s1); |
2562 | set2 = isl_set_read_from_str(ctx, s2); |
2563 | set1 = isl_set_intersect(set1, set2); |
2564 | isl_set_free(isl_set_coalesce(isl_set_copy(set1))); |
2565 | set1 = isl_set_coalesce(set1); |
2566 | isl_set_free(set1); |
2567 | |
2568 | if (!set1) |
2569 | return isl_stat_error; |
2570 | |
2571 | return isl_stat_ok; |
2572 | } |
2573 | |
2574 | /* Check that calling isl_set_coalesce does not leave other sets |
2575 | * that may share some information with the input to isl_set_coalesce |
2576 | * in an inconsistent state, for the case where one disjunct |
2577 | * is a subset of the other. |
2578 | */ |
2579 | static isl_stat test_coalesce_special4(isl_ctx *ctx) |
2580 | { |
2581 | const char *s1, *s2; |
2582 | |
2583 | s1 = "{ [a, b] : b <= 0 or a <= 1 }"; |
2584 | s2 = "{ [a, b] : -1 <= -a < b }"; |
2585 | return test_coalesce_intersection(ctx, s1, s2); |
2586 | } |
2587 | |
2588 | /* Check that calling isl_set_coalesce does not leave other sets |
2589 | * that may share some information with the input to isl_set_coalesce |
2590 | * in an inconsistent state, for the case where two disjuncts |
2591 | * can be fused. |
2592 | */ |
2593 | static isl_stat test_coalesce_special5(isl_ctx *ctx) |
2594 | { |
2595 | const char *s1, *s2; |
2596 | |
2597 | s1 = "{ [a, b, c] : b <= 0 }"; |
2598 | s2 = "{ [a, b, c] : -1 <= -a < b and (c >= 0 or c < 0) }"; |
2599 | return test_coalesce_intersection(ctx, s1, s2); |
2600 | } |
2601 | |
2602 | /* Check that calling isl_set_coalesce does not leave other sets |
2603 | * that may share some information with the input to isl_set_coalesce |
2604 | * in an inconsistent state, for the case where two disjuncts |
2605 | * can be fused and where both disjuncts have implicit equality constraints. |
2606 | */ |
2607 | static isl_stat test_coalesce_special6(isl_ctx *ctx) |
2608 | { |
2609 | const char *s1, *s2; |
2610 | |
2611 | s1 = "{ [a, b, c] : c <= 0 }"; |
2612 | s2 = "{ [a, b, c] : 0 <= a <= b <= c or (0 <= b <= c and a > 0) }"; |
2613 | return test_coalesce_intersection(ctx, s1, s2); |
2614 | } |
2615 | |
2616 | /* A specialized coalescing test case that would result in an assertion failure |
2617 | * in an earlier version of isl. Use test_coalesce_union with |
2618 | * an explicit call to isl_basic_set_union to prevent the implicit |
2619 | * equality constraints in the basic maps from being detected prior |
2620 | * to the call to isl_set_coalesce, at least at the point |
2621 | * where this test case was introduced. |
2622 | */ |
2623 | static isl_stat test_coalesce_special7(isl_ctx *ctx) |
2624 | { |
2625 | const char *str1; |
2626 | const char *str2; |
2627 | |
2628 | str1 = "{ [a, b, c=0:17] : a <= 7 and 2b <= 11 - a and " |
2629 | "c <= -7 + 2a and 2c >= - 3 + 3a - 2b }"; |
2630 | str2 = "{ [a, b, c] : c > -15a and c >= -7 + 2a and c < 0 and " |
2631 | "3c <= -5 + 5a - 3b and 2b >= 11 - a }"; |
2632 | return test_coalesce_union(ctx, str1, str2); |
2633 | } |
2634 | |
2635 | /* A specialized coalescing test case that would result in a disjunct |
2636 | * getting dropped in an earlier version of isl. Use test_coalesce_union with |
2637 | * an explicit call to isl_basic_set_union to prevent the implicit |
2638 | * equality constraints in the basic maps from being detected prior |
2639 | * to the call to isl_set_coalesce, at least at the point |
2640 | * where this test case was introduced. |
2641 | */ |
2642 | static isl_stat test_coalesce_special8(isl_ctx *ctx) |
2643 | { |
2644 | const char *str1; |
2645 | const char *str2; |
2646 | |
2647 | str1 = "{ [a, b, c] : 2c <= -a and b >= -a and b <= 5 and " |
2648 | "6c > -7a and 11c >= -5a - b and a <= 3 }"; |
2649 | str2 = "{ [a, b, c] : 6c > -7a and b >= -a and b <= 5 and " |
2650 | "11c >= -5a - b and a >= 4 and 2b <= a and 2c <= -a }"; |
2651 | return test_coalesce_union(ctx, str1, str2); |
2652 | } |
2653 | |
2654 | /* Test the functionality of isl_set_coalesce. |
2655 | * That is, check that the output is always equal to the input |
2656 | * and in some cases that the result consists of a single disjunct. |
2657 | */ |
2658 | static int test_coalesce(struct isl_ctx *ctx) |
2659 | { |
2660 | int i; |
2661 | |
2662 | for (i = 0; i < ARRAY_SIZE(coalesce_tests)(sizeof(coalesce_tests)/sizeof(*coalesce_tests)); ++i) { |
2663 | const char *str = coalesce_tests[i].str; |
2664 | int check_one = coalesce_tests[i].single_disjunct; |
2665 | if (test_coalesce_set(ctx, str, check_one) < 0) |
2666 | return -1; |
2667 | } |
2668 | |
2669 | if (test_coalesce_unbounded_wrapping(ctx) < 0) |
2670 | return -1; |
2671 | if (test_coalesce_special(ctx) < 0) |
2672 | return -1; |
2673 | if (test_coalesce_special2(ctx) < 0) |
2674 | return -1; |
2675 | if (test_coalesce_special3(ctx) < 0) |
2676 | return -1; |
2677 | if (test_coalesce_special4(ctx) < 0) |
2678 | return -1; |
2679 | if (test_coalesce_special5(ctx) < 0) |
2680 | return -1; |
2681 | if (test_coalesce_special6(ctx) < 0) |
2682 | return -1; |
2683 | if (test_coalesce_special7(ctx) < 0) |
2684 | return -1; |
2685 | if (test_coalesce_special8(ctx) < 0) |
2686 | return -1; |
2687 | |
2688 | return 0; |
2689 | } |
2690 | |
2691 | /* Construct a representation of the graph on the right of Figure 1 |
2692 | * in "Computing the Transitive Closure of a Union of |
2693 | * Affine Integer Tuple Relations". |
2694 | */ |
2695 | static __isl_give isl_map *cocoa_fig_1_right_graph(isl_ctx *ctx) |
2696 | { |
2697 | isl_setisl_map *dom; |
2698 | isl_map *up, *right; |
2699 | |
2700 | dom = isl_set_read_from_str(ctx, |
2701 | "{ [x,y] : x >= 0 and -2 x + 3 y >= 0 and x <= 3 and " |
2702 | "2 x - 3 y + 3 >= 0 }"); |
2703 | right = isl_map_read_from_str(ctx, |
2704 | "{ [x,y] -> [x2,y2] : x2 = x + 1 and y2 = y }"); |
2705 | up = isl_map_read_from_str(ctx, |
2706 | "{ [x,y] -> [x2,y2] : x2 = x and y2 = y + 1 }"); |
2707 | right = isl_map_intersect_domain(right, isl_set_copy(dom)); |
2708 | right = isl_map_intersect_range(right, isl_set_copy(dom)); |
2709 | up = isl_map_intersect_domain(up, isl_set_copy(dom)); |
2710 | up = isl_map_intersect_range(up, dom); |
2711 | return isl_map_union(up, right); |
2712 | } |
2713 | |
2714 | /* Construct a representation of the power of the graph |
2715 | * on the right of Figure 1 in "Computing the Transitive Closure of |
2716 | * a Union of Affine Integer Tuple Relations". |
2717 | */ |
2718 | static __isl_give isl_map *cocoa_fig_1_right_power(isl_ctx *ctx) |
2719 | { |
2720 | return isl_map_read_from_str(ctx, |
2721 | "{ [1] -> [[0,0] -> [0,1]]; [2] -> [[0,0] -> [1,1]]; " |
2722 | " [1] -> [[0,1] -> [1,1]]; [1] -> [[2,2] -> [3,2]]; " |
2723 | " [2] -> [[2,2] -> [3,3]]; [1] -> [[3,2] -> [3,3]] }"); |
2724 | } |
2725 | |
2726 | /* Construct a representation of the transitive closure of the graph |
2727 | * on the right of Figure 1 in "Computing the Transitive Closure of |
2728 | * a Union of Affine Integer Tuple Relations". |
2729 | */ |
2730 | static __isl_give isl_map *cocoa_fig_1_right_tc(isl_ctx *ctx) |
2731 | { |
2732 | return isl_set_unwrap(isl_map_range(cocoa_fig_1_right_power(ctx))); |
2733 | } |
2734 | |
2735 | static int test_closure(isl_ctx *ctx) |
2736 | { |
2737 | const char *str; |
2738 | isl_map *map, *map2; |
2739 | isl_bool exact, equal; |
2740 | |
2741 | /* COCOA example 1 */ |
2742 | map = isl_map_read_from_str(ctx, |
2743 | "[n] -> { [i,j] -> [i2,j2] : i2 = i + 1 and j2 = j + 1 and " |
2744 | "1 <= i and i < n and 1 <= j and j < n or " |
2745 | "i2 = i + 1 and j2 = j - 1 and " |
2746 | "1 <= i and i < n and 2 <= j and j <= n }"); |
2747 | map = isl_map_power(map, &exact); |
2748 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2748, __extension__ __PRETTY_FUNCTION__); })); |
2749 | isl_map_free(map); |
2750 | |
2751 | /* COCOA example 1 */ |
2752 | map = isl_map_read_from_str(ctx, |
2753 | "[n] -> { [i,j] -> [i2,j2] : i2 = i + 1 and j2 = j + 1 and " |
2754 | "1 <= i and i < n and 1 <= j and j < n or " |
2755 | "i2 = i + 1 and j2 = j - 1 and " |
2756 | "1 <= i and i < n and 2 <= j and j <= n }"); |
2757 | map = isl_map_transitive_closure(map, &exact); |
2758 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2758, __extension__ __PRETTY_FUNCTION__); })); |
2759 | map2 = isl_map_read_from_str(ctx, |
2760 | "[n] -> { [i,j] -> [i2,j2] : exists (k1,k2,k : " |
2761 | "1 <= i and i < n and 1 <= j and j <= n and " |
2762 | "2 <= i2 and i2 <= n and 1 <= j2 and j2 <= n and " |
2763 | "i2 = i + k1 + k2 and j2 = j + k1 - k2 and " |
2764 | "k1 >= 0 and k2 >= 0 and k1 + k2 = k and k >= 1 )}"); |
2765 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 2765, __extension__ __PRETTY_FUNCTION__ ); })); |
2766 | isl_map_free(map2); |
2767 | isl_map_free(map); |
2768 | |
2769 | map = isl_map_read_from_str(ctx, |
2770 | "[n] -> { [x] -> [y] : y = x + 1 and 0 <= x and x <= n and " |
2771 | " 0 <= y and y <= n }"); |
2772 | map = isl_map_transitive_closure(map, &exact); |
2773 | map2 = isl_map_read_from_str(ctx, |
2774 | "[n] -> { [x] -> [y] : y > x and 0 <= x and x <= n and " |
2775 | " 0 <= y and y <= n }"); |
2776 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 2776, __extension__ __PRETTY_FUNCTION__ ); })); |
2777 | isl_map_free(map2); |
2778 | isl_map_free(map); |
2779 | |
2780 | /* COCOA example 2 */ |
2781 | map = isl_map_read_from_str(ctx, |
2782 | "[n] -> { [i,j] -> [i2,j2] : i2 = i + 2 and j2 = j + 2 and " |
2783 | "1 <= i and i < n - 1 and 1 <= j and j < n - 1 or " |
2784 | "i2 = i + 2 and j2 = j - 2 and " |
2785 | "1 <= i and i < n - 1 and 3 <= j and j <= n }"); |
2786 | map = isl_map_transitive_closure(map, &exact); |
2787 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2787, __extension__ __PRETTY_FUNCTION__); })); |
2788 | map2 = isl_map_read_from_str(ctx, |
2789 | "[n] -> { [i,j] -> [i2,j2] : exists (k1,k2,k : " |
2790 | "1 <= i and i < n - 1 and 1 <= j and j <= n and " |
2791 | "3 <= i2 and i2 <= n and 1 <= j2 and j2 <= n and " |
2792 | "i2 = i + 2 k1 + 2 k2 and j2 = j + 2 k1 - 2 k2 and " |
2793 | "k1 >= 0 and k2 >= 0 and k1 + k2 = k and k >= 1) }"); |
2794 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 2794, __extension__ __PRETTY_FUNCTION__ ); })); |
2795 | isl_map_free(map); |
2796 | isl_map_free(map2); |
2797 | |
2798 | /* COCOA Fig.2 left */ |
2799 | map = isl_map_read_from_str(ctx, |
2800 | "[n] -> { [i,j] -> [i2,j2] : i2 = i + 2 and j2 = j and " |
2801 | "i <= 2 j - 3 and i <= n - 2 and j <= 2 i - 1 and " |
2802 | "j <= n or " |
2803 | "i2 = i and j2 = j + 2 and i <= 2 j - 1 and i <= n and " |
2804 | "j <= 2 i - 3 and j <= n - 2 or " |
2805 | "i2 = i + 1 and j2 = j + 1 and i <= 2 j - 1 and " |
2806 | "i <= n - 1 and j <= 2 i - 1 and j <= n - 1 }"); |
2807 | map = isl_map_transitive_closure(map, &exact); |
2808 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2808, __extension__ __PRETTY_FUNCTION__); })); |
2809 | isl_map_free(map); |
2810 | |
2811 | /* COCOA Fig.2 right */ |
2812 | map = isl_map_read_from_str(ctx, |
2813 | "[n] -> { [i,j] -> [i2,j2] : i2 = i + 3 and j2 = j and " |
2814 | "i <= 2 j - 4 and i <= n - 3 and j <= 2 i - 1 and " |
2815 | "j <= n or " |
2816 | "i2 = i and j2 = j + 3 and i <= 2 j - 1 and i <= n and " |
2817 | "j <= 2 i - 4 and j <= n - 3 or " |
2818 | "i2 = i + 1 and j2 = j + 1 and i <= 2 j - 1 and " |
2819 | "i <= n - 1 and j <= 2 i - 1 and j <= n - 1 }"); |
2820 | map = isl_map_power(map, &exact); |
2821 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2821, __extension__ __PRETTY_FUNCTION__); })); |
2822 | isl_map_free(map); |
2823 | |
2824 | /* COCOA Fig.2 right */ |
2825 | map = isl_map_read_from_str(ctx, |
2826 | "[n] -> { [i,j] -> [i2,j2] : i2 = i + 3 and j2 = j and " |
2827 | "i <= 2 j - 4 and i <= n - 3 and j <= 2 i - 1 and " |
2828 | "j <= n or " |
2829 | "i2 = i and j2 = j + 3 and i <= 2 j - 1 and i <= n and " |
2830 | "j <= 2 i - 4 and j <= n - 3 or " |
2831 | "i2 = i + 1 and j2 = j + 1 and i <= 2 j - 1 and " |
2832 | "i <= n - 1 and j <= 2 i - 1 and j <= n - 1 }"); |
2833 | map = isl_map_transitive_closure(map, &exact); |
2834 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2834, __extension__ __PRETTY_FUNCTION__); })); |
2835 | map2 = isl_map_read_from_str(ctx, |
2836 | "[n] -> { [i,j] -> [i2,j2] : exists (k1,k2,k3,k : " |
2837 | "i <= 2 j - 1 and i <= n and j <= 2 i - 1 and " |
2838 | "j <= n and 3 + i + 2 j <= 3 n and " |
2839 | "3 + 2 i + j <= 3n and i2 <= 2 j2 -1 and i2 <= n and " |
2840 | "i2 <= 3 j2 - 4 and j2 <= 2 i2 -1 and j2 <= n and " |
2841 | "13 + 4 j2 <= 11 i2 and i2 = i + 3 k1 + k3 and " |
2842 | "j2 = j + 3 k2 + k3 and k1 >= 0 and k2 >= 0 and " |
2843 | "k3 >= 0 and k1 + k2 + k3 = k and k > 0) }"); |
2844 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 2844, __extension__ __PRETTY_FUNCTION__ ); })); |
2845 | isl_map_free(map2); |
2846 | isl_map_free(map); |
2847 | |
2848 | map = cocoa_fig_1_right_graph(ctx); |
2849 | map = isl_map_transitive_closure(map, &exact); |
2850 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2850, __extension__ __PRETTY_FUNCTION__); })); |
2851 | map2 = cocoa_fig_1_right_tc(ctx); |
2852 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 2852, __extension__ __PRETTY_FUNCTION__ ); })); |
2853 | isl_map_free(map2); |
2854 | isl_map_free(map); |
2855 | |
2856 | map = cocoa_fig_1_right_graph(ctx); |
2857 | map = isl_map_power(map, &exact); |
2858 | map2 = cocoa_fig_1_right_power(ctx); |
2859 | equal = isl_map_is_equal(map, map2); |
2860 | isl_map_free(map2); |
2861 | isl_map_free(map); |
2862 | if (equal < 0) |
2863 | return -1; |
2864 | if (!exact) |
2865 | isl_die(ctx, isl_error_unknown, "power not exact", return -1)do { isl_handle_error(ctx, isl_error_unknown, "power not exact" , "polly/lib/External/isl/isl_test.c", 2865); return -1; } while (0); |
2866 | if (!equal) |
2867 | isl_die(ctx, isl_error_unknown, "unexpected power", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected power" , "polly/lib/External/isl/isl_test.c", 2867); return -1; } while (0); |
2868 | |
2869 | /* COCOA Theorem 1 counter example */ |
2870 | map = isl_map_read_from_str(ctx, |
2871 | "{ [i,j] -> [i2,j2] : i = 0 and 0 <= j and j <= 1 and " |
2872 | "i2 = 1 and j2 = j or " |
2873 | "i = 0 and j = 0 and i2 = 0 and j2 = 1 }"); |
2874 | map = isl_map_transitive_closure(map, &exact); |
2875 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2875, __extension__ __PRETTY_FUNCTION__); })); |
2876 | isl_map_free(map); |
2877 | |
2878 | map = isl_map_read_from_str(ctx, |
2879 | "[m,n] -> { [i,j] -> [i2,j2] : i2 = i and j2 = j + 2 and " |
2880 | "1 <= i,i2 <= n and 1 <= j,j2 <= m or " |
2881 | "i2 = i + 1 and 3 <= j2 - j <= 4 and " |
2882 | "1 <= i,i2 <= n and 1 <= j,j2 <= m }"); |
2883 | map = isl_map_transitive_closure(map, &exact); |
2884 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2884, __extension__ __PRETTY_FUNCTION__); })); |
2885 | isl_map_free(map); |
2886 | |
2887 | /* Kelly et al 1996, fig 12 */ |
2888 | map = isl_map_read_from_str(ctx, |
2889 | "[n] -> { [i,j] -> [i2,j2] : i2 = i and j2 = j + 1 and " |
2890 | "1 <= i,j,j+1 <= n or " |
2891 | "j = n and j2 = 1 and i2 = i + 1 and " |
2892 | "1 <= i,i+1 <= n }"); |
2893 | map = isl_map_transitive_closure(map, &exact); |
2894 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2894, __extension__ __PRETTY_FUNCTION__); })); |
2895 | map2 = isl_map_read_from_str(ctx, |
2896 | "[n] -> { [i,j] -> [i2,j2] : 1 <= j < j2 <= n and " |
2897 | "1 <= i <= n and i = i2 or " |
2898 | "1 <= i < i2 <= n and 1 <= j <= n and " |
2899 | "1 <= j2 <= n }"); |
2900 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 2900, __extension__ __PRETTY_FUNCTION__ ); })); |
2901 | isl_map_free(map2); |
2902 | isl_map_free(map); |
2903 | |
2904 | /* Omega's closure4 */ |
2905 | map = isl_map_read_from_str(ctx, |
2906 | "[m,n] -> { [x,y] -> [x2,y2] : x2 = x and y2 = y + 1 and " |
2907 | "1 <= x,y <= 10 or " |
2908 | "x2 = x + 1 and y2 = y and " |
2909 | "1 <= x <= 20 && 5 <= y <= 15 }"); |
2910 | map = isl_map_transitive_closure(map, &exact); |
2911 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2911, __extension__ __PRETTY_FUNCTION__); })); |
2912 | isl_map_free(map); |
2913 | |
2914 | map = isl_map_read_from_str(ctx, |
2915 | "[n] -> { [x] -> [y]: 1 <= n <= y - x <= 10 }"); |
2916 | map = isl_map_transitive_closure(map, &exact); |
2917 | assert(!exact)((void) sizeof ((!exact) ? 1 : 0), __extension__ ({ if (!exact ) ; else __assert_fail ("!exact", "polly/lib/External/isl/isl_test.c" , 2917, __extension__ __PRETTY_FUNCTION__); })); |
2918 | map2 = isl_map_read_from_str(ctx, |
2919 | "[n] -> { [x] -> [y] : 1 <= n <= 10 and y >= n + x }"); |
2920 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 2920, __extension__ __PRETTY_FUNCTION__ ); })); |
2921 | isl_map_free(map); |
2922 | isl_map_free(map2); |
2923 | |
2924 | str = "[n, m] -> { [i0, i1, i2, i3] -> [o0, o1, o2, o3] : " |
2925 | "i3 = 1 and o0 = i0 and o1 = -1 + i1 and o2 = -1 + i2 and " |
2926 | "o3 = -2 + i2 and i1 <= -1 + i0 and i1 >= 1 - m + i0 and " |
2927 | "i1 >= 2 and i1 <= n and i2 >= 3 and i2 <= 1 + n and i2 <= m }"; |
2928 | map = isl_map_read_from_str(ctx, str); |
2929 | map = isl_map_transitive_closure(map, &exact); |
2930 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2930, __extension__ __PRETTY_FUNCTION__); })); |
2931 | map2 = isl_map_read_from_str(ctx, str); |
2932 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 2932, __extension__ __PRETTY_FUNCTION__ ); })); |
2933 | isl_map_free(map); |
2934 | isl_map_free(map2); |
2935 | |
2936 | str = "{[0] -> [1]; [2] -> [3]}"; |
2937 | map = isl_map_read_from_str(ctx, str); |
2938 | map = isl_map_transitive_closure(map, &exact); |
2939 | assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact) ; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c" , 2939, __extension__ __PRETTY_FUNCTION__); })); |
2940 | map2 = isl_map_read_from_str(ctx, str); |
2941 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 2941, __extension__ __PRETTY_FUNCTION__ ); })); |
2942 | isl_map_free(map); |
2943 | isl_map_free(map2); |
2944 | |
2945 | str = "[n] -> { [[i0, i1, 1, 0, i0] -> [i5, 1]] -> " |
2946 | "[[i0, -1 + i1, 2, 0, i0] -> [-1 + i5, 2]] : " |
2947 | "exists (e0 = [(3 - n)/3]: i5 >= 2 and i1 >= 2 and " |
2948 | "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and " |
2949 | "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n); " |
2950 | "[[i0, i1, 2, 0, i0] -> [i5, 1]] -> " |
2951 | "[[i0, i1, 1, 0, i0] -> [-1 + i5, 2]] : " |
2952 | "exists (e0 = [(3 - n)/3]: i5 >= 2 and i1 >= 1 and " |
2953 | "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and " |
2954 | "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n); " |
2955 | "[[i0, i1, 1, 0, i0] -> [i5, 2]] -> " |
2956 | "[[i0, -1 + i1, 2, 0, i0] -> [i5, 1]] : " |
2957 | "exists (e0 = [(3 - n)/3]: i1 >= 2 and i5 >= 1 and " |
2958 | "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and " |
2959 | "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n); " |
2960 | "[[i0, i1, 2, 0, i0] -> [i5, 2]] -> " |
2961 | "[[i0, i1, 1, 0, i0] -> [i5, 1]] : " |
2962 | "exists (e0 = [(3 - n)/3]: i5 >= 1 and i1 >= 1 and " |
2963 | "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and " |
2964 | "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n) }"; |
2965 | map = isl_map_read_from_str(ctx, str); |
2966 | map = isl_map_transitive_closure(map, NULL((void*)0)); |
2967 | assert(map)((void) sizeof ((map) ? 1 : 0), __extension__ ({ if (map) ; else __assert_fail ("map", "polly/lib/External/isl/isl_test.c", 2967 , __extension__ __PRETTY_FUNCTION__); })); |
2968 | isl_map_free(map); |
2969 | |
2970 | return 0; |
2971 | } |
2972 | |
2973 | /* Check that the actual result of a boolean operation is equal |
2974 | * to the expected result. |
2975 | */ |
2976 | static isl_stat check_bool(isl_ctx *ctx, isl_bool actual, isl_bool expected) |
2977 | { |
2978 | if (actual != expected) |
2979 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect boolean operation" , "polly/lib/External/isl/isl_test.c", 2980); return isl_stat_error ; } while (0) |
2980 | "incorrect boolean operation", return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "incorrect boolean operation" , "polly/lib/External/isl/isl_test.c", 2980); return isl_stat_error ; } while (0); |
2981 | return isl_stat_ok; |
2982 | } |
2983 | |
2984 | /* Test operations on isl_bool values. |
2985 | * |
2986 | * This tests: |
2987 | * |
2988 | * isl_bool_not |
2989 | * isl_bool_ok |
2990 | */ |
2991 | static int test_isl_bool(isl_ctx *ctx) |
2992 | { |
2993 | if (check_bool(ctx, isl_bool_not(isl_bool_true), isl_bool_false) < 0) |
2994 | return -1; |
2995 | if (check_bool(ctx, isl_bool_not(isl_bool_false), isl_bool_true) < 0) |
2996 | return -1; |
2997 | if (check_bool(ctx, isl_bool_not(isl_bool_error), isl_bool_error) < 0) |
2998 | return -1; |
2999 | if (check_bool(ctx, isl_bool_ok(0), isl_bool_false) < 0) |
3000 | return -1; |
3001 | if (check_bool(ctx, isl_bool_ok(1), isl_bool_true) < 0) |
3002 | return -1; |
3003 | if (check_bool(ctx, isl_bool_ok(-1), isl_bool_true) < 0) |
3004 | return -1; |
3005 | if (check_bool(ctx, isl_bool_ok(2), isl_bool_true) < 0) |
3006 | return -1; |
3007 | if (check_bool(ctx, isl_bool_ok(-2), isl_bool_true) < 0) |
3008 | return -1; |
3009 | |
3010 | return 0; |
3011 | } |
3012 | |
3013 | static int test_lex(struct isl_ctx *ctx) |
3014 | { |
3015 | isl_space *space; |
3016 | isl_map *map; |
3017 | int empty; |
3018 | |
3019 | space = isl_space_set_alloc(ctx, 0, 0); |
3020 | map = isl_map_lex_le(space); |
3021 | empty = isl_map_is_empty(map); |
3022 | isl_map_free(map); |
3023 | |
3024 | if (empty < 0) |
3025 | return -1; |
3026 | if (empty) |
3027 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "expecting non-empty result" , "polly/lib/External/isl/isl_test.c", 3028); return -1; } while (0) |
3028 | "expecting non-empty result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "expecting non-empty result" , "polly/lib/External/isl/isl_test.c", 3028); return -1; } while (0); |
3029 | |
3030 | return 0; |
3031 | } |
3032 | |
3033 | /* Inputs for isl_map_lexmin tests. |
3034 | * "map" is the input and "lexmin" is the expected result. |
3035 | */ |
3036 | struct { |
3037 | const char *map; |
3038 | const char *lexmin; |
3039 | } lexmin_tests [] = { |
3040 | { "{ [x] -> [y] : x <= y <= 10; [x] -> [5] : -8 <= x <= 8 }", |
3041 | "{ [x] -> [5] : 6 <= x <= 8; " |
3042 | "[x] -> [x] : x <= 5 or (9 <= x <= 10) }" }, |
3043 | { "{ [x] -> [y] : 4y = x or 4y = -1 + x or 4y = -2 + x }", |
3044 | "{ [x] -> [y] : 4y = x or 4y = -1 + x or 4y = -2 + x }" }, |
3045 | { "{ [x] -> [y] : x = 4y; [x] -> [y] : x = 2y }", |
3046 | "{ [x] -> [y] : (4y = x and x >= 0) or " |
3047 | "(exists (e0 = [(x)/4], e1 = [(-2 + x)/4]: 2y = x and " |
3048 | "4e1 = -2 + x and 4e0 <= -1 + x and 4e0 >= -3 + x)) or " |
3049 | "(exists (e0 = [(x)/4]: 2y = x and 4e0 = x and x <= -4)) }" }, |
3050 | { "{ T[a] -> S[b, c] : a = 4b-2c and c >= b }", |
3051 | "{ T[a] -> S[b, c] : 2b = a and 2c = a }" }, |
3052 | /* Check that empty pieces are properly combined. */ |
3053 | { "[K, N] -> { [x, y] -> [a, b] : K+2<=N<=K+4 and x>=4 and " |
3054 | "2N-6<=x<K+N and N-1<=a<=K+N-1 and N+b-6<=a<=2N-4 and " |
3055 | "b<=2N-3K+a and 3b<=4N-K+1 and b>=N and a>=x+1 }", |
3056 | "[K, N] -> { [x, y] -> [1 + x, N] : x >= -6 + 2N and " |
3057 | "x <= -5 + 2N and x >= -1 + 3K - N and x <= -2 + K + N and " |
3058 | "x >= 4 }" }, |
3059 | { "{ [i, k, j] -> [a, b, c, d] : 8*floor((b)/8) = b and k <= 255 and " |
3060 | "a <= 255 and c <= 255 and d <= 255 - j and " |
3061 | "255 - j <= 7d <= 7 - i and 240d <= 239 + a and " |
3062 | "247d <= 247 + k - j and 247d <= 247 + k - b and " |
3063 | "247d <= 247 + i and 248 - b <= 248d <= c and " |
3064 | "254d >= i - a + b and 254d >= -a + b and " |
3065 | "255d >= -i + a - b and 1792d >= -63736 + 257b }", |
3066 | "{ [i, k, j] -> " |
3067 | "[-127762 + i + 502j, -62992 + 248j, 63240 - 248j, 255 - j] : " |
3068 | "k <= 255 and 7j >= 1778 + i and 246j >= 62738 - k and " |
3069 | "247j >= 62738 - i and 509j <= 129795 + i and " |
3070 | "742j >= 188724 - i; " |
3071 | "[0, k, j] -> [1, 0, 248, 1] : k <= 255 and 248 <= j <= 254, k }" }, |
3072 | { "{ [a] -> [b] : 0 <= b <= 255 and -509 + a <= 512b < a and " |
3073 | "16*floor((8 + b)/16) <= 7 + b; " |
3074 | "[a] -> [1] }", |
3075 | "{ [a] -> [b = 1] : a >= 510 or a <= 0; " |
3076 | "[a] -> [b = 0] : 0 < a <= 509 }" }, |
3077 | { "{ rat: [i] : 1 <= 2i <= 9 }", "{ rat: [i] : 2i = 1 }" }, |
3078 | { "{ rat: [i] : 1 <= 2i <= 9 or i >= 10 }", "{ rat: [i] : 2i = 1 }" }, |
3079 | { "{ rat: [i] : 21 <= 2i <= 29 or i = 5 }", "{ rat: [5] }" }, |
3080 | }; |
3081 | |
3082 | static int test_lexmin(struct isl_ctx *ctx) |
3083 | { |
3084 | int i; |
3085 | int equal; |
3086 | const char *str; |
3087 | isl_basic_map *bmap; |
3088 | isl_map *map, *map2; |
3089 | isl_setisl_map *set; |
3090 | isl_setisl_map *set2; |
3091 | isl_pw_multi_aff *pma; |
3092 | |
3093 | str = "[p0, p1] -> { [] -> [] : " |
3094 | "exists (e0 = [(2p1)/3], e1, e2, e3 = [(3 - p1 + 3e0)/3], " |
3095 | "e4 = [(p1)/3], e5 = [(p1 + 3e4)/3]: " |
3096 | "3e0 >= -2 + 2p1 and 3e0 >= p1 and 3e3 >= 1 - p1 + 3e0 and " |
3097 | "3e0 <= 2p1 and 3e3 >= -2 + p1 and 3e3 <= -1 + p1 and p1 >= 3 and " |
3098 | "3e5 >= -2 + 2p1 and 3e5 >= p1 and 3e5 <= -1 + p1 + 3e4 and " |
3099 | "3e4 <= p1 and 3e4 >= -2 + p1 and e3 <= -1 + e0 and " |
3100 | "3e4 >= 6 - p1 + 3e1 and 3e1 >= p1 and 3e5 >= -2 + p1 + 3e4 and " |
3101 | "2e4 >= 3 - p1 + 2e1 and e4 <= e1 and 3e3 <= 2 - p1 + 3e0 and " |
3102 | "e5 >= 1 + e1 and 3e4 >= 6 - 2p1 + 3e1 and " |
3103 | "p0 >= 2 and p1 >= p0 and 3e2 >= p1 and 3e4 >= 6 - p1 + 3e2 and " |
3104 | "e2 <= e1 and e3 >= 1 and e4 <= e2) }"; |
3105 | map = isl_map_read_from_str(ctx, str); |
3106 | map = isl_map_lexmin(map); |
3107 | isl_map_free(map); |
3108 | if (!map) |
3109 | return -1; |
3110 | |
3111 | str = "[C] -> { [obj,a,b,c] : obj <= 38 a + 7 b + 10 c and " |
3112 | "a + b <= 1 and c <= 10 b and c <= C and a,b,c,C >= 0 }"; |
3113 | set = isl_set_read_from_str(ctx, str); |
3114 | set = isl_set_lexmax(set); |
3115 | str = "[C] -> { [obj,a,b,c] : C = 8 }"; |
3116 | set2 = isl_set_read_from_str(ctx, str); |
3117 | set = isl_set_intersect(set, set2); |
3118 | assert(!isl_set_is_empty(set))((void) sizeof ((!isl_set_is_empty(set)) ? 1 : 0), __extension__ ({ if (!isl_set_is_empty(set)) ; else __assert_fail ("!isl_set_is_empty(set)" , "polly/lib/External/isl/isl_test.c", 3118, __extension__ __PRETTY_FUNCTION__ ); })); |
3119 | isl_set_free(set); |
3120 | |
3121 | for (i = 0; i < ARRAY_SIZE(lexmin_tests)(sizeof(lexmin_tests)/sizeof(*lexmin_tests)); ++i) { |
3122 | map = isl_map_read_from_str(ctx, lexmin_tests[i].map); |
3123 | map = isl_map_lexmin(map); |
3124 | map2 = isl_map_read_from_str(ctx, lexmin_tests[i].lexmin); |
3125 | equal = isl_map_is_equal(map, map2); |
3126 | isl_map_free(map); |
3127 | isl_map_free(map2); |
3128 | |
3129 | if (equal < 0) |
3130 | return -1; |
3131 | if (!equal) |
3132 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 3133); return -1; } while (0) |
3133 | "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 3133); return -1; } while (0); |
3134 | } |
3135 | |
3136 | str = "{ [i] -> [i', j] : j = i - 8i' and i' >= 0 and i' <= 7 and " |
3137 | " 8i' <= i and 8i' >= -7 + i }"; |
3138 | bmap = isl_basic_map_read_from_str(ctx, str); |
3139 | pma = isl_basic_map_lexmin_pw_multi_aff(isl_basic_map_copy(bmap)); |
3140 | map2 = isl_map_from_pw_multi_aff(pma); |
3141 | map = isl_map_from_basic_map(bmap); |
3142 | assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__ ({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)" , "polly/lib/External/isl/isl_test.c", 3142, __extension__ __PRETTY_FUNCTION__ ); })); |
3143 | isl_map_free(map); |
3144 | isl_map_free(map2); |
3145 | |
3146 | str = "[i] -> { [i', j] : j = i - 8i' and i' >= 0 and i' <= 7 and " |
3147 | " 8i' <= i and 8i' >= -7 + i }"; |
3148 | set = isl_set_read_from_str(ctx, str); |
3149 | pma = isl_set_lexmin_pw_multi_aff(isl_set_copy(set)); |
3150 | set2 = isl_set_from_pw_multi_aff(pma); |
3151 | equal = isl_set_is_equal(set, set2); |
3152 | isl_set_free(set); |
3153 | isl_set_free(set2); |
3154 | if (equal < 0) |
3155 | return -1; |
3156 | if (!equal) |
3157 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected difference between set and " "piecewise affine expression", "polly/lib/External/isl/isl_test.c" , 3159); return -1; } while (0) |
3158 | "unexpected difference between set and "do { isl_handle_error(ctx, isl_error_unknown, "unexpected difference between set and " "piecewise affine expression", "polly/lib/External/isl/isl_test.c" , 3159); return -1; } while (0) |
3159 | "piecewise affine expression", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected difference between set and " "piecewise affine expression", "polly/lib/External/isl/isl_test.c" , 3159); return -1; } while (0); |
3160 | |
3161 | return 0; |
3162 | } |
3163 | |
3164 | /* Inputs for isl_pw_multi_aff_max_multi_val tests. |
3165 | * "pma" is the input. |
3166 | * "res" is the expected result. |
3167 | */ |
3168 | static struct { |
3169 | const char *pma; |
3170 | const char *res; |
3171 | } opt_pw_tests[] = { |
3172 | { "{ [-1] -> [-1]; [1] -> [1] }", "{ [1] }" }, |
3173 | { "{ [a, b] -> [floor((b - 2*floor((-a)/4))/5)] : " |
3174 | "0 <= a, b <= 100 and b mod 2 = 0}", "{ [30] }" }, |
3175 | { "[N] -> { [i,j] -> A[i, -i, i + j] : 0 <= i,j <= N <= 10 }", |
3176 | "{ A[10, 0, 20] }" }, |
3177 | { "[N] -> {A[N, -N, 2N] : 0 <= N }", "{ A[infty, 0, infty] }" }, |
3178 | }; |
3179 | |
3180 | /* Perform basic isl_pw_multi_aff_max_multi_val tests. |
3181 | */ |
3182 | static isl_stat test_pw_max(struct isl_ctx *ctx) |
3183 | { |
3184 | int i; |
3185 | isl_pw_multi_aff *pma; |
3186 | isl_multi_val *mv; |
3187 | isl_stat r; |
3188 | |
3189 | for (i = 0; i < ARRAY_SIZE(opt_pw_tests)(sizeof(opt_pw_tests)/sizeof(*opt_pw_tests)); ++i) { |
3190 | pma = isl_pw_multi_aff_read_from_str(ctx, opt_pw_tests[i].pma); |
3191 | mv = isl_pw_multi_aff_max_multi_val(pma); |
3192 | r = multi_val_check_plain_equal(mv, opt_pw_tests[i].res); |
3193 | isl_multi_val_free(mv); |
3194 | |
3195 | if (r < 0) |
3196 | return isl_stat_error; |
3197 | } |
3198 | |
3199 | return isl_stat_ok; |
3200 | } |
3201 | |
3202 | /* A specialized isl_set_min_val test case that would return the wrong result |
3203 | * in earlier versions of isl. |
3204 | * The explicit call to isl_basic_set_union prevents the second basic set |
3205 | * from being determined to be empty prior to the call to isl_set_min_val, |
3206 | * at least at the point where this test case was introduced. |
3207 | */ |
3208 | static int test_min_special(isl_ctx *ctx) |
3209 | { |
3210 | const char *str; |
3211 | isl_basic_setisl_basic_map *bset1, *bset2; |
3212 | isl_setisl_map *set; |
3213 | isl_aff *obj; |
3214 | isl_val *res; |
3215 | int ok; |
3216 | |
3217 | str = "{ [a, b] : a >= 2 and b >= 0 and 14 - a <= b <= 9 }"; |
3218 | bset1 = isl_basic_set_read_from_str(ctx, str); |
3219 | str = "{ [a, b] : 1 <= a, b and a + b <= 1 }"; |
3220 | bset2 = isl_basic_set_read_from_str(ctx, str); |
3221 | set = isl_basic_set_union(bset1, bset2); |
3222 | obj = isl_aff_read_from_str(ctx, "{ [a, b] -> [a] }"); |
3223 | |
3224 | res = isl_set_min_val(set, obj); |
3225 | ok = isl_val_cmp_si(res, 5) == 0; |
3226 | |
3227 | isl_aff_free(obj); |
3228 | isl_set_free(set); |
3229 | isl_val_free(res); |
3230 | |
3231 | if (!res) |
3232 | return -1; |
3233 | if (!ok) |
3234 | isl_die(ctx, isl_error_unknown, "unexpected minimum",do { isl_handle_error(ctx, isl_error_unknown, "unexpected minimum" , "polly/lib/External/isl/isl_test.c", 3235); return -1; } while (0) |
3235 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected minimum" , "polly/lib/External/isl/isl_test.c", 3235); return -1; } while (0); |
3236 | |
3237 | return 0; |
3238 | } |
3239 | |
3240 | /* A specialized isl_set_min_val test case that would return an error |
3241 | * in earlier versions of isl. |
3242 | */ |
3243 | static int test_min_special2(isl_ctx *ctx) |
3244 | { |
3245 | const char *str; |
3246 | isl_basic_setisl_basic_map *bset; |
3247 | isl_aff *obj; |
3248 | isl_val *res; |
3249 | |
3250 | str = "{ [i, j, k] : 2j = i and 2k = i + 1 and i >= 2 }"; |
3251 | bset = isl_basic_set_read_from_str(ctx, str); |
3252 | |
3253 | obj = isl_aff_read_from_str(ctx, "{ [i, j, k] -> [i] }"); |
3254 | |
3255 | res = isl_basic_set_max_val(bset, obj); |
3256 | |
3257 | isl_basic_set_free(bset); |
3258 | isl_aff_free(obj); |
3259 | isl_val_free(res); |
3260 | |
3261 | if (!res) |
3262 | return -1; |
3263 | |
3264 | return 0; |
3265 | } |
3266 | |
3267 | /* Check that the result of isl_set_min_multi_pw_aff |
3268 | * on the union of the sets with string descriptions "s1" and "s2" |
3269 | * consists of a single expression (on a single cell). |
3270 | */ |
3271 | static isl_stat check_single_expr_min(isl_ctx *ctx, const char *s1, |
3272 | const char *s2) |
3273 | { |
3274 | isl_size n; |
3275 | isl_setisl_map *set1, *set2; |
3276 | isl_multi_pw_aff *mpa; |
3277 | isl_pw_multi_aff *pma; |
3278 | |
3279 | set1 = isl_set_read_from_str(ctx, s1); |
3280 | set2 = isl_set_read_from_str(ctx, s2); |
3281 | set1 = isl_set_union(set1, set2); |
3282 | mpa = isl_set_min_multi_pw_aff(set1); |
3283 | pma = isl_pw_multi_aff_from_multi_pw_aff(mpa); |
3284 | n = isl_pw_multi_aff_n_piece(pma); |
3285 | isl_pw_multi_aff_free(pma); |
3286 | |
3287 | if (n < 0) |
3288 | return isl_stat_error; |
3289 | if (n != 1) |
3290 | isl_die(ctx, isl_error_unknown, "expecting single expression",do { isl_handle_error(ctx, isl_error_unknown, "expecting single expression" , "polly/lib/External/isl/isl_test.c", 3291); return isl_stat_error ; } while (0) |
3291 | return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "expecting single expression" , "polly/lib/External/isl/isl_test.c", 3291); return isl_stat_error ; } while (0); |
3292 | return isl_stat_ok; |
3293 | } |
3294 | |
3295 | /* A specialized isl_set_min_multi_pw_aff test that checks |
3296 | * that the minimum of 2N and 3N for N >= 0 is represented |
3297 | * by a single expression, without splitting off the special case N = 0. |
3298 | * Do this for both orderings. |
3299 | */ |
3300 | static int test_min_mpa(isl_ctx *ctx) |
3301 | { |
3302 | const char *s1, *s2; |
3303 | |
3304 | s1 = "[N=0:] -> { [1, 3N:] }"; |
3305 | s2 = "[N=0:] -> { [10, 2N:] }"; |
3306 | if (check_single_expr_min(ctx, s1, s2) < 0) |
3307 | return -1; |
3308 | if (check_single_expr_min(ctx, s2, s1) < 0) |
3309 | return -1; |
3310 | |
3311 | return 0; |
3312 | } |
3313 | |
3314 | struct { |
3315 | const char *set; |
3316 | const char *obj; |
3317 | __isl_give isl_val *(*fn)(__isl_keep isl_setisl_map *set, |
3318 | __isl_keep isl_aff *obj); |
3319 | const char *res; |
3320 | } opt_tests[] = { |
3321 | { "{ [-1]; [1] }", "{ [x] -> [x] }", &isl_set_min_val, "-1" }, |
3322 | { "{ [-1]; [1] }", "{ [x] -> [x] }", &isl_set_max_val, "1" }, |
3323 | { "{ [a, b] : 0 <= a, b <= 100 and b mod 2 = 0}", |
3324 | "{ [a, b] -> [floor((b - 2*floor((-a)/4))/5)] }", |
3325 | &isl_set_max_val, "30" }, |
3326 | |
3327 | }; |
3328 | |
3329 | /* Perform basic isl_set_min_val and isl_set_max_val tests. |
3330 | * In particular, check the results on non-convex inputs. |
3331 | */ |
3332 | static int test_min(struct isl_ctx *ctx) |
3333 | { |
3334 | int i; |
3335 | isl_setisl_map *set; |
3336 | isl_aff *obj; |
3337 | isl_val *val, *res; |
3338 | isl_bool ok; |
3339 | |
3340 | for (i = 0; i < ARRAY_SIZE(opt_tests)(sizeof(opt_tests)/sizeof(*opt_tests)); ++i) { |
3341 | set = isl_set_read_from_str(ctx, opt_tests[i].set); |
3342 | obj = isl_aff_read_from_str(ctx, opt_tests[i].obj); |
3343 | res = isl_val_read_from_str(ctx, opt_tests[i].res); |
3344 | val = opt_tests[i].fn(set, obj); |
3345 | ok = isl_val_eq(res, val); |
3346 | isl_val_free(res); |
3347 | isl_val_free(val); |
3348 | isl_aff_free(obj); |
3349 | isl_set_free(set); |
3350 | |
3351 | if (ok < 0) |
3352 | return -1; |
3353 | if (!ok) |
3354 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected optimum" , "polly/lib/External/isl/isl_test.c", 3355); return -1; } while (0) |
3355 | "unexpected optimum", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected optimum" , "polly/lib/External/isl/isl_test.c", 3355); return -1; } while (0); |
3356 | } |
3357 | |
3358 | if (test_pw_max(ctx) < 0) |
3359 | return -1; |
3360 | if (test_min_special(ctx) < 0) |
3361 | return -1; |
3362 | if (test_min_special2(ctx) < 0) |
3363 | return -1; |
3364 | |
3365 | return 0; |
3366 | } |
3367 | |
3368 | struct must_may { |
3369 | isl_map *must; |
3370 | isl_map *may; |
3371 | }; |
3372 | |
3373 | static isl_stat collect_must_may(__isl_take isl_map *dep, int must, |
3374 | void *dep_user, void *user) |
3375 | { |
3376 | struct must_may *mm = (struct must_may *)user; |
3377 | |
3378 | if (must) |
3379 | mm->must = isl_map_union(mm->must, dep); |
3380 | else |
3381 | mm->may = isl_map_union(mm->may, dep); |
3382 | |
3383 | return isl_stat_ok; |
3384 | } |
3385 | |
3386 | static int common_space(void *first, void *second) |
3387 | { |
3388 | int depth = *(int *)first; |
3389 | return 2 * depth; |
3390 | } |
3391 | |
3392 | static int map_is_equal(__isl_keep isl_map *map, const char *str) |
3393 | { |
3394 | isl_map *map2; |
3395 | int equal; |
3396 | |
3397 | if (!map) |
3398 | return -1; |
3399 | |
3400 | map2 = isl_map_read_from_str(map->ctx, str); |
3401 | equal = isl_map_is_equal(map, map2); |
3402 | isl_map_free(map2); |
3403 | |
3404 | return equal; |
3405 | } |
3406 | |
3407 | static int map_check_equal(__isl_keep isl_map *map, const char *str) |
3408 | { |
3409 | int equal; |
3410 | |
3411 | equal = map_is_equal(map, str); |
3412 | if (equal < 0) |
3413 | return -1; |
3414 | if (!equal) |
3415 | isl_die(isl_map_get_ctx(map), isl_error_unknown,do { isl_handle_error(isl_map_get_ctx(map), isl_error_unknown , "result not as expected", "polly/lib/External/isl/isl_test.c" , 3416); return -1; } while (0) |
3416 | "result not as expected", return -1)do { isl_handle_error(isl_map_get_ctx(map), isl_error_unknown , "result not as expected", "polly/lib/External/isl/isl_test.c" , 3416); return -1; } while (0); |
3417 | return 0; |
3418 | } |
3419 | |
3420 | /* Is "set" equal to the set described by "str"? |
3421 | */ |
3422 | static isl_bool set_is_equal(__isl_keep isl_setisl_map *set, const char *str) |
3423 | { |
3424 | isl_setisl_map *set2; |
3425 | isl_bool equal; |
3426 | |
3427 | if (!set) |
3428 | return isl_bool_error; |
3429 | |
3430 | set2 = isl_set_read_from_str(isl_set_get_ctx(set), str); |
3431 | equal = isl_set_is_equal(set, set2); |
3432 | isl_set_free(set2); |
3433 | |
3434 | return equal; |
3435 | } |
3436 | |
3437 | /* Check that "set" is equal to the set described by "str". |
3438 | */ |
3439 | static isl_stat set_check_equal(__isl_keep isl_setisl_map *set, const char *str) |
3440 | { |
3441 | isl_bool equal; |
3442 | |
3443 | equal = set_is_equal(set, str); |
3444 | if (equal < 0) |
3445 | return isl_stat_error; |
3446 | if (!equal) |
3447 | isl_die(isl_set_get_ctx(set), isl_error_unknown,do { isl_handle_error(isl_set_get_ctx(set), isl_error_unknown , "result not as expected", "polly/lib/External/isl/isl_test.c" , 3448); return isl_stat_error; } while (0) |
3448 | "result not as expected", return isl_stat_error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_unknown , "result not as expected", "polly/lib/External/isl/isl_test.c" , 3448); return isl_stat_error; } while (0); |
3449 | return isl_stat_ok; |
3450 | } |
3451 | |
3452 | /* Is "uset" equal to the union set described by "str"? |
3453 | */ |
3454 | static isl_bool uset_is_equal(__isl_keep isl_union_set *uset, const char *str) |
3455 | { |
3456 | isl_union_set *uset2; |
3457 | isl_bool equal; |
3458 | |
3459 | if (!uset) |
3460 | return isl_bool_error; |
3461 | |
3462 | uset2 = isl_union_set_read_from_str(isl_union_set_get_ctx(uset), str); |
3463 | equal = isl_union_set_is_equal(uset, uset2); |
3464 | isl_union_set_free(uset2); |
3465 | |
3466 | return equal; |
3467 | } |
3468 | |
3469 | /* Check that "uset" is equal to the union set described by "str". |
3470 | */ |
3471 | static isl_stat uset_check_equal(__isl_keep isl_union_set *uset, |
3472 | const char *str) |
3473 | { |
3474 | isl_bool equal; |
3475 | |
3476 | equal = uset_is_equal(uset, str); |
3477 | if (equal < 0) |
3478 | return isl_stat_error; |
3479 | if (!equal) |
3480 | isl_die(isl_union_set_get_ctx(uset), isl_error_unknown,do { isl_handle_error(isl_union_set_get_ctx(uset), isl_error_unknown , "result not as expected", "polly/lib/External/isl/isl_test.c" , 3481); return isl_stat_error; } while (0) |
3481 | "result not as expected", return isl_stat_error)do { isl_handle_error(isl_union_set_get_ctx(uset), isl_error_unknown , "result not as expected", "polly/lib/External/isl/isl_test.c" , 3481); return isl_stat_error; } while (0); |
3482 | return isl_stat_ok; |
3483 | } |
3484 | |
3485 | static int test_dep(struct isl_ctx *ctx) |
3486 | { |
3487 | const char *str; |
3488 | isl_space *space; |
3489 | isl_map *map; |
3490 | isl_access_info *ai; |
3491 | isl_flow *flow; |
3492 | int depth; |
3493 | struct must_may mm; |
3494 | |
3495 | depth = 3; |
3496 | |
3497 | str = "{ [2,i,0] -> [i] : 0 <= i <= 10 }"; |
3498 | map = isl_map_read_from_str(ctx, str); |
3499 | ai = isl_access_info_alloc(map, &depth, &common_space, 2); |
3500 | |
3501 | str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }"; |
3502 | map = isl_map_read_from_str(ctx, str); |
3503 | ai = isl_access_info_add_source(ai, map, 1, &depth); |
3504 | |
3505 | str = "{ [1,i,0] -> [5] : 0 <= i <= 10 }"; |
3506 | map = isl_map_read_from_str(ctx, str); |
3507 | ai = isl_access_info_add_source(ai, map, 1, &depth); |
3508 | |
3509 | flow = isl_access_info_compute_flow(ai); |
3510 | space = isl_space_alloc(ctx, 0, 3, 3); |
3511 | mm.must = isl_map_empty(isl_space_copy(space)); |
3512 | mm.may = isl_map_empty(space); |
3513 | |
3514 | isl_flow_foreach(flow, collect_must_may, &mm); |
3515 | |
3516 | str = "{ [0,i,0] -> [2,i,0] : (0 <= i <= 4) or (6 <= i <= 10); " |
3517 | " [1,10,0] -> [2,5,0] }"; |
3518 | assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)" , "polly/lib/External/isl/isl_test.c", 3518, __extension__ __PRETTY_FUNCTION__ ); })); |
3519 | str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }"; |
3520 | assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)" , "polly/lib/External/isl/isl_test.c", 3520, __extension__ __PRETTY_FUNCTION__ ); })); |
3521 | |
3522 | isl_map_free(mm.must); |
3523 | isl_map_free(mm.may); |
3524 | isl_flow_free(flow); |
3525 | |
3526 | |
3527 | str = "{ [2,i,0] -> [i] : 0 <= i <= 10 }"; |
3528 | map = isl_map_read_from_str(ctx, str); |
3529 | ai = isl_access_info_alloc(map, &depth, &common_space, 2); |
3530 | |
3531 | str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }"; |
3532 | map = isl_map_read_from_str(ctx, str); |
3533 | ai = isl_access_info_add_source(ai, map, 1, &depth); |
3534 | |
3535 | str = "{ [1,i,0] -> [5] : 0 <= i <= 10 }"; |
3536 | map = isl_map_read_from_str(ctx, str); |
3537 | ai = isl_access_info_add_source(ai, map, 0, &depth); |
3538 | |
3539 | flow = isl_access_info_compute_flow(ai); |
3540 | space = isl_space_alloc(ctx, 0, 3, 3); |
3541 | mm.must = isl_map_empty(isl_space_copy(space)); |
3542 | mm.may = isl_map_empty(space); |
3543 | |
3544 | isl_flow_foreach(flow, collect_must_may, &mm); |
3545 | |
3546 | str = "{ [0,i,0] -> [2,i,0] : (0 <= i <= 4) or (6 <= i <= 10) }"; |
3547 | assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)" , "polly/lib/External/isl/isl_test.c", 3547, __extension__ __PRETTY_FUNCTION__ ); })); |
3548 | str = "{ [0,5,0] -> [2,5,0]; [1,i,0] -> [2,5,0] : 0 <= i <= 10 }"; |
3549 | assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)" , "polly/lib/External/isl/isl_test.c", 3549, __extension__ __PRETTY_FUNCTION__ ); })); |
3550 | |
3551 | isl_map_free(mm.must); |
3552 | isl_map_free(mm.may); |
3553 | isl_flow_free(flow); |
3554 | |
3555 | |
3556 | str = "{ [2,i,0] -> [i] : 0 <= i <= 10 }"; |
3557 | map = isl_map_read_from_str(ctx, str); |
3558 | ai = isl_access_info_alloc(map, &depth, &common_space, 2); |
3559 | |
3560 | str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }"; |
3561 | map = isl_map_read_from_str(ctx, str); |
3562 | ai = isl_access_info_add_source(ai, map, 0, &depth); |
3563 | |
3564 | str = "{ [1,i,0] -> [5] : 0 <= i <= 10 }"; |
3565 | map = isl_map_read_from_str(ctx, str); |
3566 | ai = isl_access_info_add_source(ai, map, 0, &depth); |
3567 | |
3568 | flow = isl_access_info_compute_flow(ai); |
3569 | space = isl_space_alloc(ctx, 0, 3, 3); |
3570 | mm.must = isl_map_empty(isl_space_copy(space)); |
3571 | mm.may = isl_map_empty(space); |
3572 | |
3573 | isl_flow_foreach(flow, collect_must_may, &mm); |
3574 | |
3575 | str = "{ [0,i,0] -> [2,i,0] : 0 <= i <= 10; " |
3576 | " [1,i,0] -> [2,5,0] : 0 <= i <= 10 }"; |
3577 | assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)" , "polly/lib/External/isl/isl_test.c", 3577, __extension__ __PRETTY_FUNCTION__ ); })); |
3578 | str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }"; |
3579 | assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)" , "polly/lib/External/isl/isl_test.c", 3579, __extension__ __PRETTY_FUNCTION__ ); })); |
3580 | |
3581 | isl_map_free(mm.must); |
3582 | isl_map_free(mm.may); |
3583 | isl_flow_free(flow); |
3584 | |
3585 | |
3586 | str = "{ [0,i,2] -> [i] : 0 <= i <= 10 }"; |
3587 | map = isl_map_read_from_str(ctx, str); |
3588 | ai = isl_access_info_alloc(map, &depth, &common_space, 2); |
3589 | |
3590 | str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }"; |
3591 | map = isl_map_read_from_str(ctx, str); |
3592 | ai = isl_access_info_add_source(ai, map, 0, &depth); |
3593 | |
3594 | str = "{ [0,i,1] -> [5] : 0 <= i <= 10 }"; |
3595 | map = isl_map_read_from_str(ctx, str); |
3596 | ai = isl_access_info_add_source(ai, map, 0, &depth); |
3597 | |
3598 | flow = isl_access_info_compute_flow(ai); |
3599 | space = isl_space_alloc(ctx, 0, 3, 3); |
3600 | mm.must = isl_map_empty(isl_space_copy(space)); |
3601 | mm.may = isl_map_empty(space); |
3602 | |
3603 | isl_flow_foreach(flow, collect_must_may, &mm); |
3604 | |
3605 | str = "{ [0,i,0] -> [0,i,2] : 0 <= i <= 10; " |
3606 | " [0,i,1] -> [0,5,2] : 0 <= i <= 5 }"; |
3607 | assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)" , "polly/lib/External/isl/isl_test.c", 3607, __extension__ __PRETTY_FUNCTION__ ); })); |
3608 | str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }"; |
3609 | assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)" , "polly/lib/External/isl/isl_test.c", 3609, __extension__ __PRETTY_FUNCTION__ ); })); |
3610 | |
3611 | isl_map_free(mm.must); |
3612 | isl_map_free(mm.may); |
3613 | isl_flow_free(flow); |
3614 | |
3615 | |
3616 | str = "{ [0,i,1] -> [i] : 0 <= i <= 10 }"; |
3617 | map = isl_map_read_from_str(ctx, str); |
3618 | ai = isl_access_info_alloc(map, &depth, &common_space, 2); |
3619 | |
3620 | str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }"; |
3621 | map = isl_map_read_from_str(ctx, str); |
3622 | ai = isl_access_info_add_source(ai, map, 0, &depth); |
3623 | |
3624 | str = "{ [0,i,2] -> [5] : 0 <= i <= 10 }"; |
3625 | map = isl_map_read_from_str(ctx, str); |
3626 | ai = isl_access_info_add_source(ai, map, 0, &depth); |
3627 | |
3628 | flow = isl_access_info_compute_flow(ai); |
3629 | space = isl_space_alloc(ctx, 0, 3, 3); |
3630 | mm.must = isl_map_empty(isl_space_copy(space)); |
3631 | mm.may = isl_map_empty(space); |
3632 | |
3633 | isl_flow_foreach(flow, collect_must_may, &mm); |
3634 | |
3635 | str = "{ [0,i,0] -> [0,i,1] : 0 <= i <= 10; " |
3636 | " [0,i,2] -> [0,5,1] : 0 <= i <= 4 }"; |
3637 | assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)" , "polly/lib/External/isl/isl_test.c", 3637, __extension__ __PRETTY_FUNCTION__ ); })); |
3638 | str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }"; |
3639 | assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)" , "polly/lib/External/isl/isl_test.c", 3639, __extension__ __PRETTY_FUNCTION__ ); })); |
3640 | |
3641 | isl_map_free(mm.must); |
3642 | isl_map_free(mm.may); |
3643 | isl_flow_free(flow); |
3644 | |
3645 | |
3646 | depth = 5; |
3647 | |
3648 | str = "{ [1,i,0,0,0] -> [i,j] : 0 <= i <= 10 and 0 <= j <= 10 }"; |
3649 | map = isl_map_read_from_str(ctx, str); |
3650 | ai = isl_access_info_alloc(map, &depth, &common_space, 1); |
3651 | |
3652 | str = "{ [0,i,0,j,0] -> [i,j] : 0 <= i <= 10 and 0 <= j <= 10 }"; |
3653 | map = isl_map_read_from_str(ctx, str); |
3654 | ai = isl_access_info_add_source(ai, map, 1, &depth); |
3655 | |
3656 | flow = isl_access_info_compute_flow(ai); |
3657 | space = isl_space_alloc(ctx, 0, 5, 5); |
3658 | mm.must = isl_map_empty(isl_space_copy(space)); |
3659 | mm.may = isl_map_empty(space); |
3660 | |
3661 | isl_flow_foreach(flow, collect_must_may, &mm); |
3662 | |
3663 | str = "{ [0,i,0,j,0] -> [1,i,0,0,0] : 0 <= i,j <= 10 }"; |
3664 | assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)" , "polly/lib/External/isl/isl_test.c", 3664, __extension__ __PRETTY_FUNCTION__ ); })); |
3665 | str = "{ [0,0,0,0,0] -> [0,0,0,0,0] : 1 = 0 }"; |
3666 | assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__ ({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)" , "polly/lib/External/isl/isl_test.c", 3666, __extension__ __PRETTY_FUNCTION__ ); })); |
3667 | |
3668 | isl_map_free(mm.must); |
3669 | isl_map_free(mm.may); |
3670 | isl_flow_free(flow); |
3671 | |
3672 | return 0; |
3673 | } |
3674 | |
3675 | /* Check that the dependence analysis proceeds without errors. |
3676 | * Earlier versions of isl would break down during the analysis |
3677 | * due to the use of the wrong spaces. |
3678 | */ |
3679 | static int test_flow(isl_ctx *ctx) |
3680 | { |
3681 | const char *str; |
3682 | isl_union_map *access, *schedule; |
3683 | isl_union_map *must_dep, *may_dep; |
3684 | int r; |
3685 | |
3686 | str = "{ S0[j] -> i[]; S1[j,i] -> i[]; S2[] -> i[]; S3[] -> i[] }"; |
3687 | access = isl_union_map_read_from_str(ctx, str); |
3688 | str = "{ S0[j] -> [0,j,0,0] : 0 <= j < 10; " |
3689 | "S1[j,i] -> [0,j,1,i] : 0 <= j < i < 10; " |
3690 | "S2[] -> [1,0,0,0]; " |
3691 | "S3[] -> [-1,0,0,0] }"; |
3692 | schedule = isl_union_map_read_from_str(ctx, str); |
3693 | r = isl_union_map_compute_flow(access, isl_union_map_copy(access), |
3694 | isl_union_map_copy(access), schedule, |
3695 | &must_dep, &may_dep, NULL((void*)0), NULL((void*)0)); |
3696 | isl_union_map_free(may_dep); |
3697 | isl_union_map_free(must_dep); |
3698 | |
3699 | return r; |
3700 | } |
3701 | |
3702 | struct { |
3703 | const char *map; |
3704 | int sv; |
3705 | } sv_tests[] = { |
3706 | { "[N] -> { [i] -> [f] : 0 <= i <= N and 0 <= i - 10 f <= 9 }", 1 }, |
3707 | { "[N] -> { [i] -> [f] : 0 <= i <= N and 0 <= i - 10 f <= 10 }", 0 }, |
3708 | { "{ [i] -> [3*floor(i/2) + 5*floor(i/3)] }", 1 }, |
3709 | { "{ S1[i] -> [i] : 0 <= i <= 9; S2[i] -> [i] : 0 <= i <= 9 }", 1 }, |
3710 | { "{ [i] -> S1[i] : 0 <= i <= 9; [i] -> S2[i] : 0 <= i <= 9 }", 0 }, |
3711 | { "{ A[i] -> [i]; B[i] -> [i]; B[i] -> [i + 1] }", 0 }, |
3712 | { "{ A[i] -> [i]; B[i] -> [i] : i < 0; B[i] -> [i + 1] : i > 0 }", 1 }, |
3713 | { "{ A[i] -> [i]; B[i] -> A[i] : i < 0; B[i] -> [i + 1] : i > 0 }", 1 }, |
3714 | { "{ A[i] -> [i]; B[i] -> [j] : i - 1 <= j <= i }", 0 }, |
3715 | }; |
3716 | |
3717 | int test_sv(isl_ctx *ctx) |
3718 | { |
3719 | isl_union_map *umap; |
3720 | int i; |
3721 | int sv; |
3722 | |
3723 | for (i = 0; i < ARRAY_SIZE(sv_tests)(sizeof(sv_tests)/sizeof(*sv_tests)); ++i) { |
3724 | umap = isl_union_map_read_from_str(ctx, sv_tests[i].map); |
3725 | sv = isl_union_map_is_single_valued(umap); |
3726 | isl_union_map_free(umap); |
3727 | if (sv < 0) |
3728 | return -1; |
3729 | if (sv_tests[i].sv && !sv) |
3730 | isl_die(ctx, isl_error_internal,do { isl_handle_error(ctx, isl_error_internal, "map not detected as single valued" , "polly/lib/External/isl/isl_test.c", 3731); return -1; } while (0) |
3731 | "map not detected as single valued", return -1)do { isl_handle_error(ctx, isl_error_internal, "map not detected as single valued" , "polly/lib/External/isl/isl_test.c", 3731); return -1; } while (0); |
3732 | if (!sv_tests[i].sv && sv) |
3733 | isl_die(ctx, isl_error_internal,do { isl_handle_error(ctx, isl_error_internal, "map detected as single valued" , "polly/lib/External/isl/isl_test.c", 3734); return -1; } while (0) |
3734 | "map detected as single valued", return -1)do { isl_handle_error(ctx, isl_error_internal, "map detected as single valued" , "polly/lib/External/isl/isl_test.c", 3734); return -1; } while (0); |
3735 | } |
3736 | |
3737 | return 0; |
3738 | } |
3739 | |
3740 | struct { |
3741 | const char *str; |
3742 | int bijective; |
3743 | } bijective_tests[] = { |
3744 | { "[N,M]->{[i,j] -> [i]}", 0 }, |
3745 | { "[N,M]->{[i,j] -> [i] : j=i}", 1 }, |
3746 | { "[N,M]->{[i,j] -> [i] : j=0}", 1 }, |
3747 | { "[N,M]->{[i,j] -> [i] : j=N}", 1 }, |
3748 | { "[N,M]->{[i,j] -> [j,i]}", 1 }, |
3749 | { "[N,M]->{[i,j] -> [i+j]}", 0 }, |
3750 | { "[N,M]->{[i,j] -> []}", 0 }, |
3751 | { "[N,M]->{[i,j] -> [i,j,N]}", 1 }, |
3752 | { "[N,M]->{[i,j] -> [2i]}", 0 }, |
3753 | { "[N,M]->{[i,j] -> [i,i]}", 0 }, |
3754 | { "[N,M]->{[i,j] -> [2i,i]}", 0 }, |
3755 | { "[N,M]->{[i,j] -> [2i,j]}", 1 }, |
3756 | { "[N,M]->{[i,j] -> [x,y] : 2x=i & y =j}", 1 }, |
3757 | }; |
3758 | |
3759 | static int test_bijective(struct isl_ctx *ctx) |
3760 | { |
3761 | isl_map *map; |
3762 | int i; |
3763 | int bijective; |
3764 | |
3765 | for (i = 0; i < ARRAY_SIZE(bijective_tests)(sizeof(bijective_tests)/sizeof(*bijective_tests)); ++i) { |
3766 | map = isl_map_read_from_str(ctx, bijective_tests[i].str); |
3767 | bijective = isl_map_is_bijective(map); |
3768 | isl_map_free(map); |
3769 | if (bijective < 0) |
3770 | return -1; |
3771 | if (bijective_tests[i].bijective && !bijective) |
3772 | isl_die(ctx, isl_error_internal,do { isl_handle_error(ctx, isl_error_internal, "map not detected as bijective" , "polly/lib/External/isl/isl_test.c", 3773); return -1; } while (0) |
3773 | "map not detected as bijective", return -1)do { isl_handle_error(ctx, isl_error_internal, "map not detected as bijective" , "polly/lib/External/isl/isl_test.c", 3773); return -1; } while (0); |
3774 | if (!bijective_tests[i].bijective && bijective) |
3775 | isl_die(ctx, isl_error_internal,do { isl_handle_error(ctx, isl_error_internal, "map detected as bijective" , "polly/lib/External/isl/isl_test.c", 3776); return -1; } while (0) |
3776 | "map detected as bijective", return -1)do { isl_handle_error(ctx, isl_error_internal, "map detected as bijective" , "polly/lib/External/isl/isl_test.c", 3776); return -1; } while (0); |
3777 | } |
3778 | |
3779 | return 0; |
3780 | } |
3781 | |
3782 | /* Inputs for isl_pw_qpolynomial_gist tests. |
3783 | * "pwqp" is the input, "set" is the context and "gist" is the expected result. |
3784 | */ |
3785 | struct { |
3786 | const char *pwqp; |
3787 | const char *set; |
3788 | const char *gist; |
3789 | } pwqp_gist_tests[] = { |
3790 | { "{ [i] -> i }", "{ [k] : exists a : k = 2a }", "{ [i] -> i }" }, |
3791 | { "{ [i] -> i + [ (i + [i/3])/2 ] }", "{ [10] }", "{ [i] -> 16 }" }, |
3792 | { "{ [i] -> ([(i)/2]) }", "{ [k] : exists a : k = 2a+1 }", |
3793 | "{ [i] -> -1/2 + 1/2 * i }" }, |
3794 | { "{ [i] -> i^2 : i != 0 }", "{ [i] : i != 0 }", "{ [i] -> i^2 }" }, |
3795 | { "{ [i] -> i^2 : i > 0; [i] -> i^2 : i < 0 }", "{ [i] : i != 0 }", |
3796 | "{ [i] -> i^2 }" }, |
3797 | }; |
3798 | |
3799 | /* Perform some basic isl_pw_qpolynomial_gist tests. |
3800 | */ |
3801 | static isl_stat test_pwqp_gist(isl_ctx *ctx) |
3802 | { |
3803 | int i; |
3804 | const char *str; |
3805 | isl_setisl_map *set; |
3806 | isl_pw_qpolynomial *pwqp1, *pwqp2; |
3807 | isl_bool equal; |
3808 | |
3809 | for (i = 0; i < ARRAY_SIZE(pwqp_gist_tests)(sizeof(pwqp_gist_tests)/sizeof(*pwqp_gist_tests)); ++i) { |
3810 | str = pwqp_gist_tests[i].pwqp; |
3811 | pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3812 | str = pwqp_gist_tests[i].set; |
3813 | set = isl_set_read_from_str(ctx, str); |
3814 | pwqp1 = isl_pw_qpolynomial_gist(pwqp1, set); |
3815 | str = pwqp_gist_tests[i].gist; |
3816 | pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3817 | pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2); |
3818 | equal = isl_pw_qpolynomial_is_zero(pwqp1); |
3819 | isl_pw_qpolynomial_free(pwqp1); |
3820 | |
3821 | if (equal < 0) |
3822 | return isl_stat_error; |
3823 | if (!equal) |
3824 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 3825); return isl_stat_error ; } while (0) |
3825 | "unexpected result", return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 3825); return isl_stat_error ; } while (0); |
3826 | } |
3827 | |
3828 | return isl_stat_ok; |
3829 | } |
3830 | |
3831 | /* Perform a basic isl_pw_qpolynomial_max test. |
3832 | */ |
3833 | static isl_stat test_pwqp_max(isl_ctx *ctx) |
3834 | { |
3835 | const char *str; |
3836 | isl_pw_qpolynomial *pwqp; |
3837 | isl_val *v; |
3838 | int ok; |
3839 | |
3840 | str = "{ [x=2:9, y] -> floor((x + 1)/4)^3 - floor((2x)/3)^2 }"; |
3841 | pwqp = isl_pw_qpolynomial_read_from_str(ctx, str); |
3842 | v = isl_pw_qpolynomial_max(pwqp); |
3843 | ok = isl_val_cmp_si(v, -1) == 0; |
3844 | isl_val_free(v); |
3845 | |
3846 | if (!v) |
3847 | return isl_stat_error; |
3848 | if (!ok) |
3849 | isl_die(ctx, isl_error_unknown, "unexpected maximum",do { isl_handle_error(ctx, isl_error_unknown, "unexpected maximum" , "polly/lib/External/isl/isl_test.c", 3850); return isl_stat_error ; } while (0) |
3850 | return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "unexpected maximum" , "polly/lib/External/isl/isl_test.c", 3850); return isl_stat_error ; } while (0); |
3851 | |
3852 | return isl_stat_ok; |
3853 | } |
3854 | |
3855 | static int test_pwqp(struct isl_ctx *ctx) |
3856 | { |
3857 | const char *str; |
3858 | isl_setisl_map *set; |
3859 | isl_pw_qpolynomial *pwqp1, *pwqp2; |
3860 | int equal; |
3861 | |
3862 | str = "{ [i,j,k] -> 1 + 9 * [i/5] + 7 * [j/11] + 4 * [k/13] }"; |
3863 | pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3864 | |
3865 | pwqp1 = isl_pw_qpolynomial_move_dims(pwqp1, isl_dim_param, 0, |
3866 | isl_dim_in, 1, 1); |
3867 | |
3868 | str = "[j] -> { [i,k] -> 1 + 9 * [i/5] + 7 * [j/11] + 4 * [k/13] }"; |
3869 | pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3870 | |
3871 | pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2); |
3872 | |
3873 | assert(isl_pw_qpolynomial_is_zero(pwqp1))((void) sizeof ((isl_pw_qpolynomial_is_zero(pwqp1)) ? 1 : 0), __extension__ ({ if (isl_pw_qpolynomial_is_zero(pwqp1)) ; else __assert_fail ("isl_pw_qpolynomial_is_zero(pwqp1)", "polly/lib/External/isl/isl_test.c" , 3873, __extension__ __PRETTY_FUNCTION__); })); |
3874 | |
3875 | isl_pw_qpolynomial_free(pwqp1); |
3876 | |
3877 | if (test_pwqp_gist(ctx) < 0) |
3878 | return -1; |
3879 | |
3880 | str = "{ [i] -> ([([i/2] + [i/2])/5]) }"; |
3881 | pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3882 | str = "{ [i] -> ([(2 * [i/2])/5]) }"; |
3883 | pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3884 | |
3885 | pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2); |
3886 | |
3887 | assert(isl_pw_qpolynomial_is_zero(pwqp1))((void) sizeof ((isl_pw_qpolynomial_is_zero(pwqp1)) ? 1 : 0), __extension__ ({ if (isl_pw_qpolynomial_is_zero(pwqp1)) ; else __assert_fail ("isl_pw_qpolynomial_is_zero(pwqp1)", "polly/lib/External/isl/isl_test.c" , 3887, __extension__ __PRETTY_FUNCTION__); })); |
3888 | |
3889 | isl_pw_qpolynomial_free(pwqp1); |
3890 | |
3891 | str = "{ [x] -> ([x/2] + [(x+1)/2]) }"; |
3892 | pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3893 | str = "{ [x] -> x }"; |
3894 | pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3895 | |
3896 | pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2); |
3897 | |
3898 | assert(isl_pw_qpolynomial_is_zero(pwqp1))((void) sizeof ((isl_pw_qpolynomial_is_zero(pwqp1)) ? 1 : 0), __extension__ ({ if (isl_pw_qpolynomial_is_zero(pwqp1)) ; else __assert_fail ("isl_pw_qpolynomial_is_zero(pwqp1)", "polly/lib/External/isl/isl_test.c" , 3898, __extension__ __PRETTY_FUNCTION__); })); |
3899 | |
3900 | isl_pw_qpolynomial_free(pwqp1); |
3901 | |
3902 | str = "{ [i] -> ([i/2]) : i >= 0; [i] -> ([i/3]) : i < 0 }"; |
3903 | pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3904 | pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3905 | pwqp1 = isl_pw_qpolynomial_coalesce(pwqp1); |
3906 | pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2); |
3907 | assert(isl_pw_qpolynomial_is_zero(pwqp1))((void) sizeof ((isl_pw_qpolynomial_is_zero(pwqp1)) ? 1 : 0), __extension__ ({ if (isl_pw_qpolynomial_is_zero(pwqp1)) ; else __assert_fail ("isl_pw_qpolynomial_is_zero(pwqp1)", "polly/lib/External/isl/isl_test.c" , 3907, __extension__ __PRETTY_FUNCTION__); })); |
3908 | isl_pw_qpolynomial_free(pwqp1); |
3909 | |
3910 | str = "{ [a,b,a] -> (([(2*[a/3]+b)/5]) * ([(2*[a/3]+b)/5])) }"; |
3911 | pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3912 | str = "{ [a,b,c] -> (([(2*[a/3]+b)/5]) * ([(2*[c/3]+b)/5])) }"; |
3913 | pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3914 | set = isl_set_read_from_str(ctx, "{ [a,b,a] }"); |
3915 | pwqp1 = isl_pw_qpolynomial_intersect_domain(pwqp1, set); |
3916 | equal = isl_pw_qpolynomial_plain_is_equal(pwqp1, pwqp2); |
3917 | isl_pw_qpolynomial_free(pwqp1); |
3918 | isl_pw_qpolynomial_free(pwqp2); |
3919 | if (equal < 0) |
3920 | return -1; |
3921 | if (!equal) |
3922 | isl_die(ctx, isl_error_unknown, "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 3922); return -1; } while (0); |
3923 | |
3924 | str = "{ [a,b,c] -> (([(2*[a/3]+1)/5]) * ([(2*[c/3]+1)/5])) : b = 1 }"; |
3925 | pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3926 | str = "{ [a,b,c] -> (([(2*[a/3]+b)/5]) * ([(2*[c/3]+b)/5])) }"; |
3927 | pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str); |
3928 | pwqp1 = isl_pw_qpolynomial_fix_val(pwqp1, isl_dim_set, 1, |
3929 | isl_val_one(ctx)); |
3930 | equal = isl_pw_qpolynomial_plain_is_equal(pwqp1, pwqp2); |
3931 | isl_pw_qpolynomial_free(pwqp1); |
3932 | isl_pw_qpolynomial_free(pwqp2); |
3933 | if (equal < 0) |
3934 | return -1; |
3935 | if (!equal) |
3936 | isl_die(ctx, isl_error_unknown, "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 3936); return -1; } while (0); |
3937 | |
3938 | if (test_pwqp_max(ctx) < 0) |
3939 | return -1; |
3940 | |
3941 | return 0; |
3942 | } |
3943 | |
3944 | static int test_split_periods(isl_ctx *ctx) |
3945 | { |
3946 | const char *str; |
3947 | isl_pw_qpolynomial *pwqp; |
3948 | |
3949 | str = "{ [U,V] -> 1/3 * U + 2/3 * V - [(U + 2V)/3] + [U/2] : " |
3950 | "U + 2V + 3 >= 0 and - U -2V >= 0 and - U + 10 >= 0 and " |
3951 | "U >= 0; [U,V] -> U^2 : U >= 100 }"; |
3952 | pwqp = isl_pw_qpolynomial_read_from_str(ctx, str); |
3953 | |
3954 | pwqp = isl_pw_qpolynomial_split_periods(pwqp, 2); |
3955 | |
3956 | isl_pw_qpolynomial_free(pwqp); |
3957 | |
3958 | if (!pwqp) |
3959 | return -1; |
3960 | |
3961 | return 0; |
3962 | } |
3963 | |
3964 | static int test_union(isl_ctx *ctx) |
3965 | { |
3966 | const char *str; |
3967 | isl_union_set *uset1, *uset2; |
3968 | isl_union_map *umap1, *umap2; |
3969 | int equal; |
3970 | |
3971 | str = "{ [i] : 0 <= i <= 1 }"; |
3972 | uset1 = isl_union_set_read_from_str(ctx, str); |
3973 | str = "{ [1] -> [0] }"; |
3974 | umap1 = isl_union_map_read_from_str(ctx, str); |
3975 | |
3976 | umap2 = isl_union_set_lex_gt_union_set(isl_union_set_copy(uset1), uset1); |
3977 | equal = isl_union_map_is_equal(umap1, umap2); |
3978 | |
3979 | isl_union_map_free(umap1); |
3980 | isl_union_map_free(umap2); |
3981 | |
3982 | if (equal < 0) |
3983 | return -1; |
3984 | if (!equal) |
3985 | isl_die(ctx, isl_error_unknown, "union maps not equal",do { isl_handle_error(ctx, isl_error_unknown, "union maps not equal" , "polly/lib/External/isl/isl_test.c", 3986); return -1; } while (0) |
3986 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "union maps not equal" , "polly/lib/External/isl/isl_test.c", 3986); return -1; } while (0); |
3987 | |
3988 | str = "{ A[i] -> B[i]; B[i] -> C[i]; A[0] -> C[1] }"; |
3989 | umap1 = isl_union_map_read_from_str(ctx, str); |
3990 | str = "{ A[i]; B[i] }"; |
3991 | uset1 = isl_union_set_read_from_str(ctx, str); |
3992 | |
3993 | uset2 = isl_union_map_domain(umap1); |
3994 | |
3995 | equal = isl_union_set_is_equal(uset1, uset2); |
3996 | |
3997 | isl_union_set_free(uset1); |
3998 | isl_union_set_free(uset2); |
3999 | |
4000 | if (equal < 0) |
4001 | return -1; |
4002 | if (!equal) |
4003 | isl_die(ctx, isl_error_unknown, "union sets not equal",do { isl_handle_error(ctx, isl_error_unknown, "union sets not equal" , "polly/lib/External/isl/isl_test.c", 4004); return -1; } while (0) |
4004 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "union sets not equal" , "polly/lib/External/isl/isl_test.c", 4004); return -1; } while (0); |
4005 | |
4006 | return 0; |
4007 | } |
4008 | |
4009 | /* Inputs for basic isl_pw_qpolynomial_bound tests. |
4010 | * "type" is the type of bound that should be computed. |
4011 | * "poly" is a string representation of the input. |
4012 | * "bound" is a string representation of the expected result. |
4013 | * "tight" is set if the result is expected to be tight. |
4014 | */ |
4015 | static struct { |
4016 | int tight; |
4017 | enum isl_fold type; |
4018 | const char *poly; |
4019 | const char *bound; |
4020 | } bound_tests[] = { |
4021 | /* Check that computing a bound of a non-zero polynomial |
4022 | * over an unbounded domain does not produce a rational value. |
4023 | * In particular, check that the upper bound is infinity. |
4024 | */ |
4025 | { 0, isl_fold_max, "{ [m, n] -> -m * n }", "{ max(infty) }" }, |
4026 | { 1, isl_fold_max, "{ [[a, b, c, d] -> [e]] -> 0 }", |
4027 | "{ [a, b, c, d] -> max(0) }" }, |
4028 | { 1, isl_fold_max, "{ [[x] -> [x]] -> 1 : exists a : x = 2 a }", |
4029 | "{ [x] -> max(1) : x mod 2 = 0 }" }, |
4030 | { 1, isl_fold_min, "{ [x=5:10] -> (x + 2)^2 }", "{ min(49) }" }, |
4031 | { 1, isl_fold_max, "{ [0:10] -> 1 }", "{ max(1) }" }, |
4032 | { 1, isl_fold_max, "{ [[m] -> [0:m]] -> m^2 }", |
4033 | "{ [m] -> max(m^2) : m >= 0 }" }, |
4034 | }; |
4035 | |
4036 | /* Check that the bound computation can handle differences |
4037 | * in domain dimension names of the input polynomial and its domain. |
4038 | */ |
4039 | static isl_stat test_bound_space(isl_ctx *ctx) |
4040 | { |
4041 | const char *str; |
4042 | isl_setisl_map *set; |
4043 | isl_pw_qpolynomial *pwqp; |
4044 | isl_pw_qpolynomial_fold *pwf; |
4045 | |
4046 | str = "{ [[c] -> [c]] }"; |
4047 | set = isl_set_read_from_str(ctx, str); |
4048 | str = "{ [[a] -> [b]] -> 1 }"; |
4049 | pwqp = isl_pw_qpolynomial_read_from_str(ctx, str); |
4050 | pwqp = isl_pw_qpolynomial_intersect_domain(pwqp, set); |
4051 | pwf = isl_pw_qpolynomial_bound(pwqp, isl_fold_max, NULL((void*)0)); |
4052 | isl_pw_qpolynomial_fold_free(pwf); |
4053 | |
4054 | return isl_stat_non_null(pwf); |
4055 | } |
4056 | |
4057 | /* Perform basic isl_pw_qpolynomial_bound tests. |
4058 | */ |
4059 | static int test_bound(isl_ctx *ctx) |
4060 | { |
4061 | int i; |
4062 | |
4063 | if (test_bound_space(ctx) < 0) |
4064 | return -1; |
4065 | |
4066 | for (i = 0; i < ARRAY_SIZE(bound_tests)(sizeof(bound_tests)/sizeof(*bound_tests)); ++i) { |
4067 | const char *str; |
4068 | enum isl_fold type; |
4069 | isl_bool equal, tight; |
4070 | isl_pw_qpolynomial *pwqp; |
4071 | isl_pw_qpolynomial_fold *pwf1, *pwf2; |
4072 | |
4073 | str = bound_tests[i].poly; |
4074 | pwqp = isl_pw_qpolynomial_read_from_str(ctx, str); |
4075 | type = bound_tests[i].type; |
4076 | pwf1 = isl_pw_qpolynomial_bound(pwqp, type, &tight); |
4077 | str = bound_tests[i].bound; |
4078 | pwf2 = isl_pw_qpolynomial_fold_read_from_str(ctx, str); |
4079 | equal = isl_pw_qpolynomial_fold_plain_is_equal(pwf1, pwf2); |
4080 | isl_pw_qpolynomial_fold_free(pwf2); |
4081 | isl_pw_qpolynomial_fold_free(pwf1); |
4082 | if (equal < 0) |
4083 | return -1; |
4084 | if (!equal) |
4085 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect bound result" , "polly/lib/External/isl/isl_test.c", 4086); return -1; } while (0) |
4086 | "incorrect bound result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect bound result" , "polly/lib/External/isl/isl_test.c", 4086); return -1; } while (0); |
4087 | if (bound_tests[i].tight && !tight) |
4088 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "bound unexpectedly not tight" , "polly/lib/External/isl/isl_test.c", 4089); return -1; } while (0) |
4089 | "bound unexpectedly not tight", return -1)do { isl_handle_error(ctx, isl_error_unknown, "bound unexpectedly not tight" , "polly/lib/External/isl/isl_test.c", 4089); return -1; } while (0); |
4090 | } |
4091 | |
4092 | return 0; |
4093 | } |
4094 | |
4095 | /* isl_set is defined to isl_map internally, so the corresponding elements |
4096 | * are isl_basic_map objects. |
4097 | */ |
4098 | #undef EL_BASEmap |
4099 | #undef SET_BASEunion_map |
4100 | #define EL_BASEmap basic_map |
4101 | #define SET_BASEunion_map set |
4102 | #include "isl_test_list_templ.c" |
4103 | |
4104 | #undef EL_BASEmap |
4105 | #undef SET_BASEunion_map |
4106 | #define EL_BASEmap basic_set |
4107 | #define SET_BASEunion_map union_set |
4108 | #include "isl_test_list_templ.c" |
4109 | |
4110 | #undef EL_BASEmap |
4111 | #undef SET_BASEunion_map |
4112 | #define EL_BASEmap set |
4113 | #define SET_BASEunion_map union_set |
4114 | #include "isl_test_list_templ.c" |
4115 | |
4116 | #undef EL_BASEmap |
4117 | #undef SET_BASEunion_map |
4118 | #define EL_BASEmap basic_map |
4119 | #define SET_BASEunion_map map |
4120 | #include "isl_test_list_templ.c" |
4121 | |
4122 | #undef EL_BASEmap |
4123 | #undef SET_BASEunion_map |
4124 | #define EL_BASEmap map |
4125 | #define SET_BASEunion_map union_map |
4126 | #include "isl_test_list_templ.c" |
4127 | |
4128 | /* Check that the conversion from isl objects to lists works as expected. |
4129 | */ |
4130 | static int test_get_list(isl_ctx *ctx) |
4131 | { |
4132 | if (test_get_list_basic_map_from_set(ctx, "{ [0]; [2]; [3] }")) |
4133 | return -1; |
4134 | if (test_get_list_basic_set_from_union_set(ctx, "{ A[0]; B[2]; B[3] }")) |
4135 | return -1; |
4136 | if (test_get_list_set_from_union_set(ctx, "{ A[0]; A[2]; B[3] }")) |
4137 | return -1; |
4138 | if (test_get_list_basic_map_from_map(ctx, |
4139 | "{ [0] -> [0]; [2] -> [0]; [3] -> [0] }")) |
4140 | return -1; |
4141 | if (test_get_list_map_from_union_map(ctx, |
4142 | "{ A[0] -> [0]; A[2] -> [0]; B[3] -> [0] }")) |
4143 | return -1; |
4144 | |
4145 | return 0; |
4146 | } |
4147 | |
4148 | static int test_lift(isl_ctx *ctx) |
4149 | { |
4150 | const char *str; |
4151 | isl_basic_map *bmap; |
4152 | isl_basic_setisl_basic_map *bset; |
4153 | |
4154 | str = "{ [i0] : exists e0 : i0 = 4e0 }"; |
4155 | bset = isl_basic_set_read_from_str(ctx, str); |
4156 | bset = isl_basic_set_lift(bset); |
4157 | bmap = isl_basic_map_from_range(bset); |
4158 | bset = isl_basic_map_domain(bmap); |
4159 | isl_basic_set_free(bset); |
4160 | |
4161 | return 0; |
4162 | } |
4163 | |
4164 | /* Check that isl_set_is_subset is not confused by identical |
4165 | * integer divisions. |
4166 | * The call to isl_set_normalize ensures that the equality constraints |
4167 | * a = b = 0 are discovered, turning e0 and e1 into identical |
4168 | * integer divisions. Any further simplification would remove |
4169 | * the duplicate integer divisions. |
4170 | */ |
4171 | static isl_stat test_subset_duplicate_integer_divisions(isl_ctx *ctx) |
4172 | { |
4173 | const char *str; |
4174 | isl_bool is_subset; |
4175 | isl_setisl_map *set1, *set2; |
4176 | |
4177 | str = "{ [a, b, c, d] : " |
4178 | "exists (e0 = floor((a + d)/4), e1 = floor((d)/4), " |
4179 | "e2 = floor((-a - d + 4 *floor((a + d)/4))/10), " |
4180 | "e3 = floor((-d + 4*floor((d)/4))/10): " |
4181 | "10e2 = -a - 2c - d + 4e0 and 10e3 = -2c - d + 4e1 and " |
4182 | "b >= 0 and a <= 0 and b <= a) }"; |
4183 | set1 = isl_set_read_from_str(ctx, str); |
4184 | set2 = isl_set_read_from_str(ctx, str); |
4185 | set2 = isl_set_normalize(set2); |
4186 | |
4187 | is_subset = isl_set_is_subset(set1, set2); |
4188 | |
4189 | isl_set_free(set1); |
4190 | isl_set_free(set2); |
4191 | |
4192 | if (is_subset < 0) |
4193 | return isl_stat_error; |
4194 | if (!is_subset) |
4195 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "set is not considered to be a subset of itself" , "polly/lib/External/isl/isl_test.c", 4197); return isl_stat_error ; } while (0) |
4196 | "set is not considered to be a subset of itself",do { isl_handle_error(ctx, isl_error_unknown, "set is not considered to be a subset of itself" , "polly/lib/External/isl/isl_test.c", 4197); return isl_stat_error ; } while (0) |
4197 | return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "set is not considered to be a subset of itself" , "polly/lib/External/isl/isl_test.c", 4197); return isl_stat_error ; } while (0); |
4198 | |
4199 | return isl_stat_ok; |
4200 | } |
4201 | |
4202 | struct { |
4203 | const char *set1; |
4204 | const char *set2; |
4205 | int subset; |
4206 | } subset_tests[] = { |
4207 | { "{ [112, 0] }", |
4208 | "{ [i0, i1] : exists (e0 = [(i0 - i1)/16], e1: " |
4209 | "16e0 <= i0 - i1 and 16e0 >= -15 + i0 - i1 and " |
4210 | "16e1 <= i1 and 16e0 >= -i1 and 16e1 >= -i0 + i1) }", 1 }, |
4211 | { "{ [65] }", |
4212 | "{ [i] : exists (e0 = [(255i)/256], e1 = [(127i + 65e0)/191], " |
4213 | "e2 = [(3i + 61e1)/65], e3 = [(52i + 12e2)/61], " |
4214 | "e4 = [(2i + e3)/3], e5 = [(4i + e3)/4], e6 = [(8i + e3)/12]: " |
4215 | "3e4 = 2i + e3 and 4e5 = 4i + e3 and 12e6 = 8i + e3 and " |
4216 | "i <= 255 and 64e3 >= -45 + 67i and i >= 0 and " |
4217 | "256e0 <= 255i and 256e0 >= -255 + 255i and " |
4218 | "191e1 <= 127i + 65e0 and 191e1 >= -190 + 127i + 65e0 and " |
4219 | "65e2 <= 3i + 61e1 and 65e2 >= -64 + 3i + 61e1 and " |
4220 | "61e3 <= 52i + 12e2 and 61e3 >= -60 + 52i + 12e2) }", 1 }, |
4221 | { "{ [i] : 0 <= i <= 10 }", "{ rat: [i] : 0 <= i <= 10 }", 1 }, |
4222 | { "{ rat: [i] : 0 <= i <= 10 }", "{ [i] : 0 <= i <= 10 }", 0 }, |
4223 | { "{ rat: [0] }", "{ [i] : 0 <= i <= 10 }", 1 }, |
4224 | { "{ rat: [(1)/2] }", "{ [i] : 0 <= i <= 10 }", 0 }, |
4225 | { "{ [t, i] : (exists (e0 = [(2 + t)/4]: 4e0 <= 2 + t and " |
4226 | "4e0 >= -1 + t and i >= 57 and i <= 62 and " |
4227 | "4e0 <= 62 + t - i and 4e0 >= -61 + t + i and " |
4228 | "t >= 0 and t <= 511 and 4e0 <= -57 + t + i and " |
4229 | "4e0 >= 58 + t - i and i >= 58 + t and i >= 62 - t)) }", |
4230 | "{ [i0, i1] : (exists (e0 = [(4 + i0)/4]: 4e0 <= 62 + i0 - i1 and " |
4231 | "4e0 >= 1 + i0 and i0 >= 0 and i0 <= 511 and " |
4232 | "4e0 <= -57 + i0 + i1)) or " |
4233 | "(exists (e0 = [(2 + i0)/4]: 4e0 <= i0 and " |
4234 | "4e0 >= 58 + i0 - i1 and i0 >= 2 and i0 <= 511 and " |
4235 | "4e0 >= -61 + i0 + i1)) or " |
4236 | "(i1 <= 66 - i0 and i0 >= 2 and i1 >= 59 + i0) }", 1 }, |
4237 | { "[a, b] -> { : a = 0 and b = -1 }", "[b, a] -> { : b >= -10 }", 1 }, |
4238 | }; |
4239 | |
4240 | static int test_subset(isl_ctx *ctx) |
4241 | { |
4242 | int i; |
4243 | isl_setisl_map *set1, *set2; |
4244 | int subset; |
4245 | |
4246 | if (test_subset_duplicate_integer_divisions(ctx) < 0) |
4247 | return -1; |
4248 | |
4249 | for (i = 0; i < ARRAY_SIZE(subset_tests)(sizeof(subset_tests)/sizeof(*subset_tests)); ++i) { |
4250 | set1 = isl_set_read_from_str(ctx, subset_tests[i].set1); |
4251 | set2 = isl_set_read_from_str(ctx, subset_tests[i].set2); |
4252 | subset = isl_set_is_subset(set1, set2); |
4253 | isl_set_free(set1); |
4254 | isl_set_free(set2); |
4255 | if (subset < 0) |
4256 | return -1; |
4257 | if (subset != subset_tests[i].subset) |
4258 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect subset result" , "polly/lib/External/isl/isl_test.c", 4259); return -1; } while (0) |
4259 | "incorrect subset result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect subset result" , "polly/lib/External/isl/isl_test.c", 4259); return -1; } while (0); |
4260 | } |
4261 | |
4262 | return 0; |
4263 | } |
4264 | |
4265 | /* Perform a set subtraction with a set that has a non-obviously empty disjunct. |
4266 | * Older versions of isl would fail on such cases. |
4267 | */ |
4268 | static isl_stat test_subtract_empty(isl_ctx *ctx) |
4269 | { |
4270 | const char *str; |
4271 | isl_setisl_map *s1, *s2; |
4272 | |
4273 | s1 = isl_set_read_from_str(ctx, "{ [0] }"); |
4274 | str = "{ [a] : (exists (e0, e1, e2: 1056e1 <= 32 + a - 33e0 and " |
4275 | "1089e1 >= a - 33e0 and 1089e1 <= 1 + a - 33e0 and " |
4276 | "33e2 >= -a + 33e0 + 1056e1 and " |
4277 | "33e2 < -2a + 66e0 + 2112e1)) or a = 0 }"; |
4278 | s2 = isl_set_read_from_str(ctx, str); |
4279 | s1 = isl_set_subtract(s1, s2); |
4280 | isl_set_free(s1); |
4281 | |
4282 | return isl_stat_non_null(s1); |
4283 | } |
4284 | |
4285 | struct { |
4286 | const char *minuend; |
4287 | const char *subtrahend; |
4288 | const char *difference; |
4289 | } subtract_domain_tests[] = { |
4290 | { "{ A[i] -> B[i] }", "{ A[i] }", "{ }" }, |
4291 | { "{ A[i] -> B[i] }", "{ B[i] }", "{ A[i] -> B[i] }" }, |
4292 | { "{ A[i] -> B[i] }", "{ A[i] : i > 0 }", "{ A[i] -> B[i] : i <= 0 }" }, |
4293 | }; |
4294 | |
4295 | static int test_subtract(isl_ctx *ctx) |
4296 | { |
4297 | int i; |
4298 | isl_union_map *umap1, *umap2; |
4299 | isl_union_pw_multi_aff *upma1, *upma2; |
4300 | isl_union_set *uset; |
4301 | int equal; |
4302 | |
4303 | if (test_subtract_empty(ctx) < 0) |
4304 | return -1; |
4305 | |
4306 | for (i = 0; i < ARRAY_SIZE(subtract_domain_tests)(sizeof(subtract_domain_tests)/sizeof(*subtract_domain_tests) ); ++i) { |
4307 | umap1 = isl_union_map_read_from_str(ctx, |
4308 | subtract_domain_tests[i].minuend); |
4309 | uset = isl_union_set_read_from_str(ctx, |
4310 | subtract_domain_tests[i].subtrahend); |
4311 | umap2 = isl_union_map_read_from_str(ctx, |
4312 | subtract_domain_tests[i].difference); |
4313 | umap1 = isl_union_map_subtract_domain(umap1, uset); |
4314 | equal = isl_union_map_is_equal(umap1, umap2); |
4315 | isl_union_map_free(umap1); |
4316 | isl_union_map_free(umap2); |
4317 | if (equal < 0) |
4318 | return -1; |
4319 | if (!equal) |
4320 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect subtract domain result" , "polly/lib/External/isl/isl_test.c", 4321); return -1; } while (0) |
4321 | "incorrect subtract domain result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect subtract domain result" , "polly/lib/External/isl/isl_test.c", 4321); return -1; } while (0); |
4322 | } |
4323 | |
4324 | for (i = 0; i < ARRAY_SIZE(subtract_domain_tests)(sizeof(subtract_domain_tests)/sizeof(*subtract_domain_tests) ); ++i) { |
4325 | upma1 = isl_union_pw_multi_aff_read_from_str(ctx, |
4326 | subtract_domain_tests[i].minuend); |
4327 | uset = isl_union_set_read_from_str(ctx, |
4328 | subtract_domain_tests[i].subtrahend); |
4329 | upma2 = isl_union_pw_multi_aff_read_from_str(ctx, |
4330 | subtract_domain_tests[i].difference); |
4331 | upma1 = isl_union_pw_multi_aff_subtract_domain(upma1, uset); |
4332 | equal = isl_union_pw_multi_aff_plain_is_equal(upma1, upma2); |
4333 | isl_union_pw_multi_aff_free(upma1); |
4334 | isl_union_pw_multi_aff_free(upma2); |
4335 | if (equal < 0) |
4336 | return -1; |
4337 | if (!equal) |
4338 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect subtract domain result" , "polly/lib/External/isl/isl_test.c", 4339); return -1; } while (0) |
4339 | "incorrect subtract domain result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect subtract domain result" , "polly/lib/External/isl/isl_test.c", 4339); return -1; } while (0); |
4340 | } |
4341 | |
4342 | return 0; |
4343 | } |
4344 | |
4345 | /* Check that intersecting the empty basic set with another basic set |
4346 | * does not increase the number of constraints. In particular, |
4347 | * the empty basic set should maintain its canonical representation. |
4348 | */ |
4349 | static int test_intersect_1(isl_ctx *ctx) |
4350 | { |
4351 | isl_size n1, n2; |
4352 | isl_basic_setisl_basic_map *bset1, *bset2; |
4353 | |
4354 | bset1 = isl_basic_set_read_from_str(ctx, "{ [a,b,c] : 1 = 0 }"); |
4355 | bset2 = isl_basic_set_read_from_str(ctx, "{ [1,2,3] }"); |
4356 | n1 = isl_basic_set_n_constraint(bset1); |
4357 | bset1 = isl_basic_set_intersect(bset1, bset2); |
4358 | n2 = isl_basic_set_n_constraint(bset1); |
4359 | isl_basic_set_free(bset1); |
4360 | if (n1 < 0 || n2 < 0) |
4361 | return -1; |
4362 | if (n1 != n2) |
4363 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "number of constraints of empty set changed" , "polly/lib/External/isl/isl_test.c", 4365); return -1; } while (0) |
4364 | "number of constraints of empty set changed",do { isl_handle_error(ctx, isl_error_unknown, "number of constraints of empty set changed" , "polly/lib/External/isl/isl_test.c", 4365); return -1; } while (0) |
4365 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "number of constraints of empty set changed" , "polly/lib/External/isl/isl_test.c", 4365); return -1; } while (0); |
4366 | |
4367 | return 0; |
4368 | } |
4369 | |
4370 | /* Check that intersecting a set with itself does not cause |
4371 | * an explosion in the number of disjuncts. |
4372 | */ |
4373 | static isl_stat test_intersect_2(isl_ctx *ctx) |
4374 | { |
4375 | int i; |
4376 | isl_setisl_map *set; |
4377 | |
4378 | set = isl_set_read_from_str(ctx, "{ [x,y] : x >= 0 or y >= 0 }"); |
4379 | for (i = 0; i < 100; ++i) |
4380 | set = isl_set_intersect(set, isl_set_copy(set)); |
4381 | isl_set_free(set); |
4382 | if (!set) |
4383 | return isl_stat_error; |
4384 | return isl_stat_ok; |
4385 | } |
4386 | |
4387 | /* Perform some intersection tests. |
4388 | */ |
4389 | static int test_intersect(isl_ctx *ctx) |
4390 | { |
4391 | if (test_intersect_1(ctx) < 0) |
4392 | return -1; |
4393 | if (test_intersect_2(ctx) < 0) |
4394 | return -1; |
4395 | |
4396 | return 0; |
4397 | } |
4398 | |
4399 | int test_factorize(isl_ctx *ctx) |
4400 | { |
4401 | const char *str; |
4402 | isl_basic_setisl_basic_map *bset; |
4403 | isl_factorizer *f; |
4404 | |
4405 | str = "{ [i0, i1, i2, i3, i4, i5, i6, i7] : 3i5 <= 2 - 2i0 and " |
4406 | "i0 >= -2 and i6 >= 1 + i3 and i7 >= 0 and 3i5 >= -2i0 and " |
4407 | "2i4 <= i2 and i6 >= 1 + 2i0 + 3i1 and i4 <= -1 and " |
4408 | "i6 >= 1 + 2i0 + 3i5 and i6 <= 2 + 2i0 + 3i5 and " |
4409 | "3i5 <= 2 - 2i0 - i2 + 3i4 and i6 <= 2 + 2i0 + 3i1 and " |
4410 | "i0 <= -1 and i7 <= i2 + i3 - 3i4 - i6 and " |
4411 | "3i5 >= -2i0 - i2 + 3i4 }"; |
4412 | bset = isl_basic_set_read_from_str(ctx, str); |
4413 | f = isl_basic_set_factorizer(bset); |
4414 | isl_basic_set_free(bset); |
4415 | isl_factorizer_free(f); |
4416 | if (!f) |
4417 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "failed to construct factorizer" , "polly/lib/External/isl/isl_test.c", 4418); return -1; } while (0) |
4418 | "failed to construct factorizer", return -1)do { isl_handle_error(ctx, isl_error_unknown, "failed to construct factorizer" , "polly/lib/External/isl/isl_test.c", 4418); return -1; } while (0); |
4419 | |
4420 | str = "{ [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] : " |
4421 | "i12 <= 2 + i0 - i11 and 2i8 >= -i4 and i11 >= i1 and " |
4422 | "3i5 <= -i2 and 2i11 >= -i4 - 2i7 and i11 <= 3 + i0 + 3i9 and " |
4423 | "i11 <= -i4 - 2i7 and i12 >= -i10 and i2 >= -2 and " |
4424 | "i11 >= i1 + 3i10 and i11 >= 1 + i0 + 3i9 and " |
4425 | "i11 <= 1 - i4 - 2i8 and 6i6 <= 6 - i2 and 3i6 >= 1 - i2 and " |
4426 | "i11 <= 2 + i1 and i12 <= i4 + i11 and i12 >= i0 - i11 and " |
4427 | "3i5 >= -2 - i2 and i12 >= -1 + i4 + i11 and 3i3 <= 3 - i2 and " |
4428 | "9i6 <= 11 - i2 + 6i5 and 3i3 >= 1 - i2 and " |
4429 | "9i6 <= 5 - i2 + 6i3 and i12 <= -1 and i2 <= 0 }"; |
4430 | bset = isl_basic_set_read_from_str(ctx, str); |
4431 | f = isl_basic_set_factorizer(bset); |
4432 | isl_basic_set_free(bset); |
4433 | isl_factorizer_free(f); |
4434 | if (!f) |
4435 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "failed to construct factorizer" , "polly/lib/External/isl/isl_test.c", 4436); return -1; } while (0) |
4436 | "failed to construct factorizer", return -1)do { isl_handle_error(ctx, isl_error_unknown, "failed to construct factorizer" , "polly/lib/External/isl/isl_test.c", 4436); return -1; } while (0); |
4437 | |
4438 | return 0; |
4439 | } |
4440 | |
4441 | static isl_stat check_injective(__isl_take isl_map *map, void *user) |
4442 | { |
4443 | int *injective = user; |
4444 | |
4445 | *injective = isl_map_is_injective(map); |
4446 | isl_map_free(map); |
4447 | |
4448 | if (*injective < 0 || !*injective) |
4449 | return isl_stat_error; |
4450 | |
4451 | return isl_stat_ok; |
4452 | } |
4453 | |
4454 | int test_one_schedule(isl_ctx *ctx, const char *d, const char *w, |
4455 | const char *r, const char *s, int tilable, int parallel) |
4456 | { |
4457 | int i; |
4458 | isl_union_set *D; |
4459 | isl_union_map *W, *R, *S; |
4460 | isl_union_map *empty; |
4461 | isl_union_map *dep_raw, *dep_war, *dep_waw, *dep; |
4462 | isl_union_map *validity, *proximity, *coincidence; |
4463 | isl_union_map *schedule; |
4464 | isl_union_map *test; |
4465 | isl_union_set *delta; |
4466 | isl_union_set *domain; |
4467 | isl_setisl_map *delta_set; |
4468 | isl_setisl_map *slice; |
4469 | isl_setisl_map *origin; |
4470 | isl_schedule_constraints *sc; |
4471 | isl_schedule *sched; |
4472 | int is_nonneg, is_parallel, is_tilable, is_injection, is_complete; |
4473 | isl_size n; |
4474 | |
4475 | D = isl_union_set_read_from_str(ctx, d); |
4476 | W = isl_union_map_read_from_str(ctx, w); |
4477 | R = isl_union_map_read_from_str(ctx, r); |
4478 | S = isl_union_map_read_from_str(ctx, s); |
4479 | |
4480 | W = isl_union_map_intersect_domain(W, isl_union_set_copy(D)); |
4481 | R = isl_union_map_intersect_domain(R, isl_union_set_copy(D)); |
4482 | |
4483 | empty = isl_union_map_empty(isl_union_map_get_space(S)); |
4484 | isl_union_map_compute_flow(isl_union_map_copy(R), |
4485 | isl_union_map_copy(W), empty, |
4486 | isl_union_map_copy(S), |
4487 | &dep_raw, NULL((void*)0), NULL((void*)0), NULL((void*)0)); |
4488 | isl_union_map_compute_flow(isl_union_map_copy(W), |
4489 | isl_union_map_copy(W), |
4490 | isl_union_map_copy(R), |
4491 | isl_union_map_copy(S), |
4492 | &dep_waw, &dep_war, NULL((void*)0), NULL((void*)0)); |
4493 | |
4494 | dep = isl_union_map_union(dep_waw, dep_war); |
4495 | dep = isl_union_map_union(dep, dep_raw); |
4496 | validity = isl_union_map_copy(dep); |
4497 | coincidence = isl_union_map_copy(dep); |
4498 | proximity = isl_union_map_copy(dep); |
4499 | |
4500 | sc = isl_schedule_constraints_on_domain(isl_union_set_copy(D)); |
4501 | sc = isl_schedule_constraints_set_validity(sc, validity); |
4502 | sc = isl_schedule_constraints_set_coincidence(sc, coincidence); |
4503 | sc = isl_schedule_constraints_set_proximity(sc, proximity); |
4504 | sched = isl_schedule_constraints_compute_schedule(sc); |
4505 | schedule = isl_schedule_get_map(sched); |
4506 | isl_schedule_free(sched); |
4507 | isl_union_map_free(W); |
4508 | isl_union_map_free(R); |
4509 | isl_union_map_free(S); |
4510 | |
4511 | is_injection = 1; |
4512 | isl_union_map_foreach_map(schedule, &check_injective, &is_injection); |
4513 | |
4514 | domain = isl_union_map_domain(isl_union_map_copy(schedule)); |
4515 | is_complete = isl_union_set_is_subset(D, domain); |
4516 | isl_union_set_free(D); |
4517 | isl_union_set_free(domain); |
4518 | |
4519 | test = isl_union_map_reverse(isl_union_map_copy(schedule)); |
4520 | test = isl_union_map_apply_range(test, dep); |
4521 | test = isl_union_map_apply_range(test, schedule); |
4522 | |
4523 | delta = isl_union_map_deltas(test); |
4524 | n = isl_union_set_n_set(delta); |
4525 | if (n < 0) { |
4526 | isl_union_set_free(delta); |
4527 | return -1; |
4528 | } |
4529 | if (n == 0) { |
4530 | is_tilable = 1; |
4531 | is_parallel = 1; |
4532 | is_nonneg = 1; |
4533 | isl_union_set_free(delta); |
4534 | } else { |
4535 | isl_size dim; |
4536 | |
4537 | delta_set = isl_set_from_union_set(delta); |
4538 | |
4539 | slice = isl_set_universe(isl_set_get_space(delta_set)); |
4540 | for (i = 0; i < tilable; ++i) |
4541 | slice = isl_set_lower_bound_si(slice, isl_dim_set, i, 0); |
4542 | is_tilable = isl_set_is_subset(delta_set, slice); |
4543 | isl_set_free(slice); |
4544 | |
4545 | slice = isl_set_universe(isl_set_get_space(delta_set)); |
4546 | for (i = 0; i < parallel; ++i) |
4547 | slice = isl_set_fix_si(slice, isl_dim_set, i, 0); |
4548 | is_parallel = isl_set_is_subset(delta_set, slice); |
4549 | isl_set_free(slice); |
4550 | |
4551 | origin = isl_set_universe(isl_set_get_space(delta_set)); |
4552 | dim = isl_set_dim(origin, isl_dim_set); |
4553 | if (dim < 0) |
4554 | origin = isl_set_free(origin); |
4555 | for (i = 0; i < dim; ++i) |
4556 | origin = isl_set_fix_si(origin, isl_dim_set, i, 0); |
4557 | |
4558 | delta_set = isl_set_union(delta_set, isl_set_copy(origin)); |
4559 | delta_set = isl_set_lexmin(delta_set); |
4560 | |
4561 | is_nonneg = isl_set_is_equal(delta_set, origin); |
4562 | |
4563 | isl_set_free(origin); |
4564 | isl_set_free(delta_set); |
4565 | } |
4566 | |
4567 | if (is_nonneg < 0 || is_parallel < 0 || is_tilable < 0 || |
4568 | is_injection < 0 || is_complete < 0) |
4569 | return -1; |
4570 | if (!is_complete) |
4571 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "generated schedule incomplete" , "polly/lib/External/isl/isl_test.c", 4572); return -1; } while (0) |
4572 | "generated schedule incomplete", return -1)do { isl_handle_error(ctx, isl_error_unknown, "generated schedule incomplete" , "polly/lib/External/isl/isl_test.c", 4572); return -1; } while (0); |
4573 | if (!is_injection) |
4574 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not injective on each statement" , "polly/lib/External/isl/isl_test.c", 4576); return -1; } while (0) |
4575 | "generated schedule not injective on each statement",do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not injective on each statement" , "polly/lib/External/isl/isl_test.c", 4576); return -1; } while (0) |
4576 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not injective on each statement" , "polly/lib/External/isl/isl_test.c", 4576); return -1; } while (0); |
4577 | if (!is_nonneg) |
4578 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "negative dependences in generated schedule" , "polly/lib/External/isl/isl_test.c", 4580); return -1; } while (0) |
4579 | "negative dependences in generated schedule",do { isl_handle_error(ctx, isl_error_unknown, "negative dependences in generated schedule" , "polly/lib/External/isl/isl_test.c", 4580); return -1; } while (0) |
4580 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "negative dependences in generated schedule" , "polly/lib/External/isl/isl_test.c", 4580); return -1; } while (0); |
4581 | if (!is_tilable) |
4582 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as tilable as expected" , "polly/lib/External/isl/isl_test.c", 4584); return -1; } while (0) |
4583 | "generated schedule not as tilable as expected",do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as tilable as expected" , "polly/lib/External/isl/isl_test.c", 4584); return -1; } while (0) |
4584 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as tilable as expected" , "polly/lib/External/isl/isl_test.c", 4584); return -1; } while (0); |
4585 | if (!is_parallel) |
4586 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as parallel as expected" , "polly/lib/External/isl/isl_test.c", 4588); return -1; } while (0) |
4587 | "generated schedule not as parallel as expected",do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as parallel as expected" , "polly/lib/External/isl/isl_test.c", 4588); return -1; } while (0) |
4588 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as parallel as expected" , "polly/lib/External/isl/isl_test.c", 4588); return -1; } while (0); |
4589 | |
4590 | return 0; |
4591 | } |
4592 | |
4593 | /* Compute a schedule for the given instance set, validity constraints, |
4594 | * proximity constraints and context and return a corresponding union map |
4595 | * representation. |
4596 | */ |
4597 | static __isl_give isl_union_map *compute_schedule_with_context(isl_ctx *ctx, |
4598 | const char *domain, const char *validity, const char *proximity, |
4599 | const char *context) |
4600 | { |
4601 | isl_setisl_map *con; |
4602 | isl_union_set *dom; |
4603 | isl_union_map *dep; |
4604 | isl_union_map *prox; |
4605 | isl_schedule_constraints *sc; |
4606 | isl_schedule *schedule; |
4607 | isl_union_map *sched; |
4608 | |
4609 | con = isl_set_read_from_str(ctx, context); |
4610 | dom = isl_union_set_read_from_str(ctx, domain); |
4611 | dep = isl_union_map_read_from_str(ctx, validity); |
4612 | prox = isl_union_map_read_from_str(ctx, proximity); |
4613 | sc = isl_schedule_constraints_on_domain(dom); |
4614 | sc = isl_schedule_constraints_set_context(sc, con); |
4615 | sc = isl_schedule_constraints_set_validity(sc, dep); |
4616 | sc = isl_schedule_constraints_set_proximity(sc, prox); |
4617 | schedule = isl_schedule_constraints_compute_schedule(sc); |
4618 | sched = isl_schedule_get_map(schedule); |
4619 | isl_schedule_free(schedule); |
4620 | |
4621 | return sched; |
4622 | } |
4623 | |
4624 | /* Compute a schedule for the given instance set, validity constraints and |
4625 | * proximity constraints and return a corresponding union map representation. |
4626 | */ |
4627 | static __isl_give isl_union_map *compute_schedule(isl_ctx *ctx, |
4628 | const char *domain, const char *validity, const char *proximity) |
4629 | { |
4630 | return compute_schedule_with_context(ctx, domain, validity, proximity, |
4631 | "{ : }"); |
4632 | } |
4633 | |
4634 | /* Check that a schedule can be constructed on the given domain |
4635 | * with the given validity and proximity constraints. |
4636 | */ |
4637 | static int test_has_schedule(isl_ctx *ctx, const char *domain, |
4638 | const char *validity, const char *proximity) |
4639 | { |
4640 | isl_union_map *sched; |
4641 | |
4642 | sched = compute_schedule(ctx, domain, validity, proximity); |
4643 | if (!sched) |
4644 | return -1; |
4645 | |
4646 | isl_union_map_free(sched); |
4647 | return 0; |
4648 | } |
4649 | |
4650 | int test_special_schedule(isl_ctx *ctx, const char *domain, |
4651 | const char *validity, const char *proximity, const char *expected_sched) |
4652 | { |
4653 | isl_union_map *sched1, *sched2; |
4654 | int equal; |
4655 | |
4656 | sched1 = compute_schedule(ctx, domain, validity, proximity); |
4657 | sched2 = isl_union_map_read_from_str(ctx, expected_sched); |
4658 | |
4659 | equal = isl_union_map_is_equal(sched1, sched2); |
4660 | isl_union_map_free(sched1); |
4661 | isl_union_map_free(sched2); |
4662 | |
4663 | if (equal < 0) |
4664 | return -1; |
4665 | if (!equal) |
4666 | isl_die(ctx, isl_error_unknown, "unexpected schedule",do { isl_handle_error(ctx, isl_error_unknown, "unexpected schedule" , "polly/lib/External/isl/isl_test.c", 4667); return -1; } while (0) |
4667 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected schedule" , "polly/lib/External/isl/isl_test.c", 4667); return -1; } while (0); |
4668 | |
4669 | return 0; |
4670 | } |
4671 | |
4672 | /* Check that the schedule map is properly padded, i.e., that the range |
4673 | * lives in a single space. |
4674 | */ |
4675 | static int test_padded_schedule(isl_ctx *ctx) |
4676 | { |
4677 | const char *str; |
4678 | isl_union_set *D; |
4679 | isl_union_map *validity, *proximity; |
4680 | isl_schedule_constraints *sc; |
4681 | isl_schedule *sched; |
4682 | isl_union_map *umap; |
4683 | isl_union_set *range; |
4684 | isl_setisl_map *set; |
4685 | |
4686 | str = "[N] -> { S0[i] : 0 <= i <= N; S1[i, j] : 0 <= i, j <= N }"; |
4687 | D = isl_union_set_read_from_str(ctx, str); |
4688 | validity = isl_union_map_empty(isl_union_set_get_space(D)); |
4689 | proximity = isl_union_map_copy(validity); |
4690 | sc = isl_schedule_constraints_on_domain(D); |
4691 | sc = isl_schedule_constraints_set_validity(sc, validity); |
4692 | sc = isl_schedule_constraints_set_proximity(sc, proximity); |
4693 | sched = isl_schedule_constraints_compute_schedule(sc); |
4694 | umap = isl_schedule_get_map(sched); |
4695 | isl_schedule_free(sched); |
4696 | range = isl_union_map_range(umap); |
4697 | set = isl_set_from_union_set(range); |
4698 | isl_set_free(set); |
4699 | |
4700 | if (!set) |
4701 | return -1; |
4702 | |
4703 | return 0; |
4704 | } |
4705 | |
4706 | /* Check that conditional validity constraints are also taken into |
4707 | * account across bands. |
4708 | * In particular, try to make sure that live ranges D[1,0]->C[2,1] and |
4709 | * D[2,0]->C[3,0] are not local in the outer band of the generated schedule |
4710 | * and then check that the adjacent order constraint C[2,1]->D[2,0] |
4711 | * is enforced by the rest of the schedule. |
4712 | */ |
4713 | static int test_special_conditional_schedule_constraints(isl_ctx *ctx) |
4714 | { |
4715 | const char *str; |
4716 | isl_union_set *domain; |
4717 | isl_union_map *validity, *proximity, *condition; |
4718 | isl_union_map *sink, *source, *dep; |
4719 | isl_schedule_constraints *sc; |
4720 | isl_schedule *schedule; |
4721 | isl_union_access_info *access; |
4722 | isl_union_flow *flow; |
4723 | int empty; |
4724 | |
4725 | str = "[n] -> { C[k, i] : k <= -1 + n and i >= 0 and i <= -1 + k; " |
4726 | "A[k] : k >= 1 and k <= -1 + n; " |
4727 | "B[k, i] : k <= -1 + n and i >= 0 and i <= -1 + k; " |
4728 | "D[k, i] : k <= -1 + n and i >= 0 and i <= -1 + k }"; |
4729 | domain = isl_union_set_read_from_str(ctx, str); |
4730 | sc = isl_schedule_constraints_on_domain(domain); |
4731 | str = "[n] -> { D[k, i] -> C[1 + k, k - i] : " |
4732 | "k <= -2 + n and i >= 1 and i <= -1 + k; " |
4733 | "D[k, i] -> C[1 + k, i] : " |
4734 | "k <= -2 + n and i >= 1 and i <= -1 + k; " |
4735 | "D[k, 0] -> C[1 + k, k] : k >= 1 and k <= -2 + n; " |
4736 | "D[k, 0] -> C[1 + k, 0] : k >= 1 and k <= -2 + n }"; |
4737 | validity = isl_union_map_read_from_str(ctx, str); |
4738 | sc = isl_schedule_constraints_set_validity(sc, validity); |
4739 | str = "[n] -> { C[k, i] -> D[k, i] : " |
4740 | "0 <= i <= -1 + k and k <= -1 + n }"; |
4741 | proximity = isl_union_map_read_from_str(ctx, str); |
4742 | sc = isl_schedule_constraints_set_proximity(sc, proximity); |
4743 | str = "[n] -> { [D[k, i] -> a[]] -> [C[1 + k, k - i] -> b[]] : " |
4744 | "i <= -1 + k and i >= 1 and k <= -2 + n; " |
4745 | "[B[k, i] -> c[]] -> [B[k, 1 + i] -> c[]] : " |
4746 | "k <= -1 + n and i >= 0 and i <= -2 + k }"; |
4747 | condition = isl_union_map_read_from_str(ctx, str); |
4748 | str = "[n] -> { [B[k, i] -> e[]] -> [D[k, i] -> a[]] : " |
4749 | "i >= 0 and i <= -1 + k and k <= -1 + n; " |
4750 | "[C[k, i] -> b[]] -> [D[k', -1 + k - i] -> a[]] : " |
4751 | "i >= 0 and i <= -1 + k and k <= -1 + n and " |
4752 | "k' <= -1 + n and k' >= k - i and k' >= 1 + k; " |
4753 | "[C[k, i] -> b[]] -> [D[k, -1 + k - i] -> a[]] : " |
4754 | "i >= 0 and i <= -1 + k and k <= -1 + n; " |
4755 | "[B[k, i] -> c[]] -> [A[k'] -> d[]] : " |
4756 | "k <= -1 + n and i >= 0 and i <= -1 + k and " |
4757 | "k' >= 1 and k' <= -1 + n and k' >= 1 + k }"; |
4758 | validity = isl_union_map_read_from_str(ctx, str); |
4759 | sc = isl_schedule_constraints_set_conditional_validity(sc, condition, |
4760 | validity); |
4761 | schedule = isl_schedule_constraints_compute_schedule(sc); |
4762 | str = "{ D[2,0] -> [] }"; |
4763 | sink = isl_union_map_read_from_str(ctx, str); |
4764 | access = isl_union_access_info_from_sink(sink); |
4765 | str = "{ C[2,1] -> [] }"; |
4766 | source = isl_union_map_read_from_str(ctx, str); |
4767 | access = isl_union_access_info_set_must_source(access, source); |
4768 | access = isl_union_access_info_set_schedule(access, schedule); |
4769 | flow = isl_union_access_info_compute_flow(access); |
4770 | dep = isl_union_flow_get_must_dependence(flow); |
4771 | isl_union_flow_free(flow); |
4772 | empty = isl_union_map_is_empty(dep); |
4773 | isl_union_map_free(dep); |
4774 | |
4775 | if (empty < 0) |
4776 | return -1; |
4777 | if (empty) |
4778 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "conditional validity not respected" , "polly/lib/External/isl/isl_test.c", 4779); return -1; } while (0) |
4779 | "conditional validity not respected", return -1)do { isl_handle_error(ctx, isl_error_unknown, "conditional validity not respected" , "polly/lib/External/isl/isl_test.c", 4779); return -1; } while (0); |
4780 | |
4781 | return 0; |
4782 | } |
4783 | |
4784 | /* Check that the test for violated conditional validity constraints |
4785 | * is not confused by domain compression. |
4786 | * In particular, earlier versions of isl would apply |
4787 | * a schedule on the compressed domains to the original domains, |
4788 | * resulting in a failure to detect that the default schedule |
4789 | * violates the conditional validity constraints. |
4790 | */ |
4791 | static int test_special_conditional_schedule_constraints_2(isl_ctx *ctx) |
4792 | { |
4793 | const char *str; |
4794 | isl_bool empty; |
4795 | isl_union_set *domain; |
4796 | isl_union_map *validity, *condition; |
4797 | isl_schedule_constraints *sc; |
4798 | isl_schedule *schedule; |
4799 | isl_union_map *umap; |
4800 | isl_map *map, *ge; |
4801 | |
4802 | str = "{ A[0, i] : 0 <= i <= 10; B[1, i] : 0 <= i <= 10 }"; |
4803 | domain = isl_union_set_read_from_str(ctx, str); |
4804 | sc = isl_schedule_constraints_on_domain(domain); |
4805 | str = "{ B[1, i] -> A[0, i + 1] }"; |
4806 | condition = isl_union_map_read_from_str(ctx, str); |
4807 | str = "{ A[0, i] -> B[1, i - 1] }"; |
4808 | validity = isl_union_map_read_from_str(ctx, str); |
4809 | sc = isl_schedule_constraints_set_conditional_validity(sc, condition, |
4810 | isl_union_map_copy(validity)); |
4811 | schedule = isl_schedule_constraints_compute_schedule(sc); |
4812 | umap = isl_schedule_get_map(schedule); |
4813 | isl_schedule_free(schedule); |
4814 | validity = isl_union_map_apply_domain(validity, |
4815 | isl_union_map_copy(umap)); |
4816 | validity = isl_union_map_apply_range(validity, umap); |
4817 | map = isl_map_from_union_map(validity); |
4818 | ge = isl_map_lex_ge(isl_space_domain(isl_map_get_space(map))); |
4819 | map = isl_map_intersect(map, ge); |
4820 | empty = isl_map_is_empty(map); |
4821 | isl_map_free(map); |
4822 | |
4823 | if (empty < 0) |
4824 | return -1; |
4825 | if (!empty) |
4826 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "conditional validity constraints not satisfied" , "polly/lib/External/isl/isl_test.c", 4828); return -1; } while (0) |
4827 | "conditional validity constraints not satisfied",do { isl_handle_error(ctx, isl_error_unknown, "conditional validity constraints not satisfied" , "polly/lib/External/isl/isl_test.c", 4828); return -1; } while (0) |
4828 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "conditional validity constraints not satisfied" , "polly/lib/External/isl/isl_test.c", 4828); return -1; } while (0); |
4829 | |
4830 | return 0; |
4831 | } |
4832 | |
4833 | /* Input for testing of schedule construction based on |
4834 | * conditional constraints. |
4835 | * |
4836 | * domain is the iteration domain |
4837 | * flow are the flow dependences, which determine the validity and |
4838 | * proximity constraints |
4839 | * condition are the conditions on the conditional validity constraints |
4840 | * conditional_validity are the conditional validity constraints |
4841 | * outer_band_n is the expected number of members in the outer band |
4842 | */ |
4843 | struct { |
4844 | const char *domain; |
4845 | const char *flow; |
4846 | const char *condition; |
4847 | const char *conditional_validity; |
4848 | int outer_band_n; |
4849 | } live_range_tests[] = { |
4850 | /* Contrived example that illustrates that we need to keep |
4851 | * track of tagged condition dependences and |
4852 | * tagged conditional validity dependences |
4853 | * in isl_sched_edge separately. |
4854 | * In particular, the conditional validity constraints on A |
4855 | * cannot be satisfied, |
4856 | * but they can be ignored because there are no corresponding |
4857 | * condition constraints. However, we do have an additional |
4858 | * conditional validity constraint that maps to the same |
4859 | * dependence relation |
4860 | * as the condition constraint on B. If we did not make a distinction |
4861 | * between tagged condition and tagged conditional validity |
4862 | * dependences, then we |
4863 | * could end up treating this shared dependence as an condition |
4864 | * constraint on A, forcing a localization of the conditions, |
4865 | * which is impossible. |
4866 | */ |
4867 | { "{ S[i] : 0 <= 1 < 100; T[i] : 0 <= 1 < 100 }", |
4868 | "{ S[i] -> S[i+1] : 0 <= i < 99 }", |
4869 | "{ [S[i] -> B[]] -> [S[i+1] -> B[]] : 0 <= i < 99 }", |
4870 | "{ [S[i] -> A[]] -> [T[i'] -> A[]] : 0 <= i', i < 100 and i != i';" |
4871 | "[T[i] -> A[]] -> [S[i'] -> A[]] : 0 <= i', i < 100 and i != i';" |
4872 | "[S[i] -> A[]] -> [S[i+1] -> A[]] : 0 <= i < 99 }", |
4873 | 1 |
4874 | }, |
4875 | /* TACO 2013 Fig. 7 */ |
4876 | { "[n] -> { S1[i,j] : 0 <= i,j < n; S2[i,j] : 0 <= i,j < n }", |
4877 | "[n] -> { S1[i,j] -> S2[i,j] : 0 <= i,j < n;" |
4878 | "S2[i,j] -> S2[i,j+1] : 0 <= i < n and 0 <= j < n - 1 }", |
4879 | "[n] -> { [S1[i,j] -> t[]] -> [S2[i,j] -> t[]] : 0 <= i,j < n;" |
4880 | "[S2[i,j] -> x1[]] -> [S2[i,j+1] -> x1[]] : " |
4881 | "0 <= i < n and 0 <= j < n - 1 }", |
4882 | "[n] -> { [S2[i,j] -> t[]] -> [S1[i,j'] -> t[]] : " |
4883 | "0 <= i < n and 0 <= j < j' < n;" |
4884 | "[S2[i,j] -> t[]] -> [S1[i',j'] -> t[]] : " |
4885 | "0 <= i < i' < n and 0 <= j,j' < n;" |
4886 | "[S2[i,j] -> x1[]] -> [S2[i,j'] -> x1[]] : " |
4887 | "0 <= i,j,j' < n and j < j' }", |
4888 | 2 |
4889 | }, |
4890 | /* TACO 2013 Fig. 7, without tags */ |
4891 | { "[n] -> { S1[i,j] : 0 <= i,j < n; S2[i,j] : 0 <= i,j < n }", |
4892 | "[n] -> { S1[i,j] -> S2[i,j] : 0 <= i,j < n;" |
4893 | "S2[i,j] -> S2[i,j+1] : 0 <= i < n and 0 <= j < n - 1 }", |
4894 | "[n] -> { S1[i,j] -> S2[i,j] : 0 <= i,j < n;" |
4895 | "S2[i,j] -> S2[i,j+1] : 0 <= i < n and 0 <= j < n - 1 }", |
4896 | "[n] -> { S2[i,j] -> S1[i,j'] : 0 <= i < n and 0 <= j < j' < n;" |
4897 | "S2[i,j] -> S1[i',j'] : 0 <= i < i' < n and 0 <= j,j' < n;" |
4898 | "S2[i,j] -> S2[i,j'] : 0 <= i,j,j' < n and j < j' }", |
4899 | 1 |
4900 | }, |
4901 | /* TACO 2013 Fig. 12 */ |
4902 | { "{ S1[i,0] : 0 <= i <= 1; S2[i,j] : 0 <= i <= 1 and 1 <= j <= 2;" |
4903 | "S3[i,3] : 0 <= i <= 1 }", |
4904 | "{ S1[i,0] -> S2[i,1] : 0 <= i <= 1;" |
4905 | "S2[i,1] -> S2[i,2] : 0 <= i <= 1;" |
4906 | "S2[i,2] -> S3[i,3] : 0 <= i <= 1 }", |
4907 | "{ [S1[i,0]->t[]] -> [S2[i,1]->t[]] : 0 <= i <= 1;" |
4908 | "[S2[i,1]->t[]] -> [S2[i,2]->t[]] : 0 <= i <= 1;" |
4909 | "[S2[i,2]->t[]] -> [S3[i,3]->t[]] : 0 <= i <= 1 }", |
4910 | "{ [S2[i,1]->t[]] -> [S2[i,2]->t[]] : 0 <= i <= 1;" |
4911 | "[S2[0,j]->t[]] -> [S2[1,j']->t[]] : 1 <= j,j' <= 2;" |
4912 | "[S2[0,j]->t[]] -> [S1[1,0]->t[]] : 1 <= j <= 2;" |
4913 | "[S3[0,3]->t[]] -> [S2[1,j]->t[]] : 1 <= j <= 2;" |
4914 | "[S3[0,3]->t[]] -> [S1[1,0]->t[]] }", |
4915 | 1 |
4916 | } |
4917 | }; |
4918 | |
4919 | /* Test schedule construction based on conditional constraints. |
4920 | * In particular, check the number of members in the outer band node |
4921 | * as an indication of whether tiling is possible or not. |
4922 | */ |
4923 | static int test_conditional_schedule_constraints(isl_ctx *ctx) |
4924 | { |
4925 | int i; |
4926 | isl_union_set *domain; |
4927 | isl_union_map *condition; |
4928 | isl_union_map *flow; |
4929 | isl_union_map *validity; |
4930 | isl_schedule_constraints *sc; |
4931 | isl_schedule *schedule; |
4932 | isl_schedule_node *node; |
4933 | isl_size n_member; |
4934 | |
4935 | if (test_special_conditional_schedule_constraints(ctx) < 0) |
4936 | return -1; |
4937 | if (test_special_conditional_schedule_constraints_2(ctx) < 0) |
4938 | return -1; |
4939 | |
4940 | for (i = 0; i < ARRAY_SIZE(live_range_tests)(sizeof(live_range_tests)/sizeof(*live_range_tests)); ++i) { |
4941 | domain = isl_union_set_read_from_str(ctx, |
4942 | live_range_tests[i].domain); |
4943 | flow = isl_union_map_read_from_str(ctx, |
4944 | live_range_tests[i].flow); |
4945 | condition = isl_union_map_read_from_str(ctx, |
4946 | live_range_tests[i].condition); |
4947 | validity = isl_union_map_read_from_str(ctx, |
4948 | live_range_tests[i].conditional_validity); |
4949 | sc = isl_schedule_constraints_on_domain(domain); |
4950 | sc = isl_schedule_constraints_set_validity(sc, |
4951 | isl_union_map_copy(flow)); |
4952 | sc = isl_schedule_constraints_set_proximity(sc, flow); |
4953 | sc = isl_schedule_constraints_set_conditional_validity(sc, |
4954 | condition, validity); |
4955 | schedule = isl_schedule_constraints_compute_schedule(sc); |
4956 | node = isl_schedule_get_root(schedule); |
4957 | while (node && |
4958 | isl_schedule_node_get_type(node) != isl_schedule_node_band) |
4959 | node = isl_schedule_node_first_child(node); |
4960 | n_member = isl_schedule_node_band_n_member(node); |
4961 | isl_schedule_node_free(node); |
4962 | isl_schedule_free(schedule); |
4963 | |
4964 | if (!schedule || n_member < 0) |
4965 | return -1; |
4966 | if (n_member != live_range_tests[i].outer_band_n) |
4967 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected number of members in outer band" , "polly/lib/External/isl/isl_test.c", 4969); return -1; } while (0) |
4968 | "unexpected number of members in outer band",do { isl_handle_error(ctx, isl_error_unknown, "unexpected number of members in outer band" , "polly/lib/External/isl/isl_test.c", 4969); return -1; } while (0) |
4969 | return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected number of members in outer band" , "polly/lib/External/isl/isl_test.c", 4969); return -1; } while (0); |
4970 | } |
4971 | return 0; |
4972 | } |
4973 | |
4974 | /* Check that the schedule computed for the given instance set and |
4975 | * dependence relation strongly satisfies the dependences. |
4976 | * In particular, check that no instance is scheduled before |
4977 | * or together with an instance on which it depends. |
4978 | * Earlier versions of isl would produce a schedule that |
4979 | * only weakly satisfies the dependences. |
4980 | */ |
4981 | static int test_strongly_satisfying_schedule(isl_ctx *ctx) |
4982 | { |
4983 | const char *domain, *dep; |
4984 | isl_union_map *D, *schedule; |
4985 | isl_map *map, *ge; |
4986 | int empty; |
4987 | |
4988 | domain = "{ B[i0, i1] : 0 <= i0 <= 1 and 0 <= i1 <= 11; " |
4989 | "A[i0] : 0 <= i0 <= 1 }"; |
4990 | dep = "{ B[i0, i1] -> B[i0, 1 + i1] : 0 <= i0 <= 1 and 0 <= i1 <= 10; " |
4991 | "B[0, 11] -> A[1]; A[i0] -> B[i0, 0] : 0 <= i0 <= 1 }"; |
4992 | schedule = compute_schedule(ctx, domain, dep, dep); |
4993 | D = isl_union_map_read_from_str(ctx, dep); |
4994 | D = isl_union_map_apply_domain(D, isl_union_map_copy(schedule)); |
4995 | D = isl_union_map_apply_range(D, schedule); |
4996 | map = isl_map_from_union_map(D); |
4997 | ge = isl_map_lex_ge(isl_space_domain(isl_map_get_space(map))); |
4998 | map = isl_map_intersect(map, ge); |
4999 | empty = isl_map_is_empty(map); |
5000 | isl_map_free(map); |
5001 | |
5002 | if (empty < 0) |
5003 | return -1; |
5004 | if (!empty) |
5005 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "dependences not strongly satisfied" , "polly/lib/External/isl/isl_test.c", 5006); return -1; } while (0) |
5006 | "dependences not strongly satisfied", return -1)do { isl_handle_error(ctx, isl_error_unknown, "dependences not strongly satisfied" , "polly/lib/External/isl/isl_test.c", 5006); return -1; } while (0); |
5007 | |
5008 | return 0; |
5009 | } |
5010 | |
5011 | /* Compute a schedule for input where the instance set constraints |
5012 | * conflict with the context constraints. |
5013 | * Earlier versions of isl did not properly handle this situation. |
5014 | */ |
5015 | static int test_conflicting_context_schedule(isl_ctx *ctx) |
5016 | { |
5017 | isl_union_map *schedule; |
5018 | const char *domain, *context; |
5019 | |
5020 | domain = "[n] -> { A[] : n >= 0 }"; |
5021 | context = "[n] -> { : n < 0 }"; |
5022 | schedule = compute_schedule_with_context(ctx, |
5023 | domain, "{}", "{}", context); |
5024 | isl_union_map_free(schedule); |
5025 | |
5026 | if (!schedule) |
5027 | return -1; |
5028 | |
5029 | return 0; |
5030 | } |
5031 | |
5032 | /* Check that a set of schedule constraints that only allow for |
5033 | * a coalescing schedule still produces a schedule even if the user |
5034 | * request a non-coalescing schedule. Earlier versions of isl |
5035 | * would not handle this case correctly. |
5036 | */ |
5037 | static int test_coalescing_schedule(isl_ctx *ctx) |
5038 | { |
5039 | const char *domain, *dep; |
5040 | isl_union_set *I; |
5041 | isl_union_map *D; |
5042 | isl_schedule_constraints *sc; |
5043 | isl_schedule *schedule; |
5044 | int treat_coalescing; |
5045 | |
5046 | domain = "{ S[a, b] : 0 <= a <= 1 and 0 <= b <= 1 }"; |
5047 | dep = "{ S[a, b] -> S[a + b, 1 - b] }"; |
5048 | I = isl_union_set_read_from_str(ctx, domain); |
5049 | D = isl_union_map_read_from_str(ctx, dep); |
5050 | sc = isl_schedule_constraints_on_domain(I); |
5051 | sc = isl_schedule_constraints_set_validity(sc, D); |
5052 | treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx); |
5053 | isl_options_set_schedule_treat_coalescing(ctx, 1); |
5054 | schedule = isl_schedule_constraints_compute_schedule(sc); |
5055 | isl_options_set_schedule_treat_coalescing(ctx, treat_coalescing); |
5056 | isl_schedule_free(schedule); |
5057 | if (!schedule) |
5058 | return -1; |
5059 | return 0; |
5060 | } |
5061 | |
5062 | /* Check that the scheduler does not perform any needless |
5063 | * compound skewing. Earlier versions of isl would compute |
5064 | * schedules in terms of transformed schedule coefficients and |
5065 | * would not accurately keep track of the sum of the original |
5066 | * schedule coefficients. It could then produce the schedule |
5067 | * S[t,i,j,k] -> [t, 2t + i, 2t + i + j, 2t + i + j + k] |
5068 | * for the input below instead of the schedule below. |
5069 | */ |
5070 | static int test_skewing_schedule(isl_ctx *ctx) |
5071 | { |
5072 | const char *D, *V, *P, *S; |
5073 | |
5074 | D = "[n] -> { S[t,i,j,k] : 0 <= t,i,j,k < n }"; |
5075 | V = "[n] -> { S[t,i,j,k] -> S[t+1,a,b,c] : 0 <= t,i,j,k,a,b,c < n and " |
5076 | "-2 <= a-i <= 2 and -1 <= a-i + b-j <= 1 and " |
5077 | "-1 <= a-i + b-j + c-k <= 1 }"; |
5078 | P = "{ }"; |
5079 | S = "{ S[t,i,j,k] -> [t, 2t + i, t + i + j, 2t + k] }"; |
5080 | |
5081 | return test_special_schedule(ctx, D, V, P, S); |
5082 | } |
5083 | |
5084 | int test_schedule(isl_ctx *ctx) |
5085 | { |
5086 | const char *D, *W, *R, *V, *P, *S; |
5087 | int max_coincidence; |
5088 | int treat_coalescing; |
5089 | |
5090 | /* Handle resulting schedule with zero bands. */ |
5091 | if (test_one_schedule(ctx, "{[]}", "{}", "{}", "{[] -> []}", 0, 0) < 0) |
5092 | return -1; |
5093 | |
5094 | /* Jacobi */ |
5095 | D = "[T,N] -> { S1[t,i] : 1 <= t <= T and 2 <= i <= N - 1 }"; |
5096 | W = "{ S1[t,i] -> a[t,i] }"; |
5097 | R = "{ S1[t,i] -> a[t-1,i]; S1[t,i] -> a[t-1,i-1]; " |
5098 | "S1[t,i] -> a[t-1,i+1] }"; |
5099 | S = "{ S1[t,i] -> [t,i] }"; |
5100 | if (test_one_schedule(ctx, D, W, R, S, 2, 0) < 0) |
5101 | return -1; |
5102 | |
5103 | /* Fig. 5 of CC2008 */ |
5104 | D = "[N] -> { S_0[i, j] : i >= 0 and i <= -1 + N and j >= 2 and " |
5105 | "j <= -1 + N }"; |
5106 | W = "[N] -> { S_0[i, j] -> a[i, j] : i >= 0 and i <= -1 + N and " |
5107 | "j >= 2 and j <= -1 + N }"; |
5108 | R = "[N] -> { S_0[i, j] -> a[j, i] : i >= 0 and i <= -1 + N and " |
5109 | "j >= 2 and j <= -1 + N; " |
5110 | "S_0[i, j] -> a[i, -1 + j] : i >= 0 and i <= -1 + N and " |
5111 | "j >= 2 and j <= -1 + N }"; |
5112 | S = "[N] -> { S_0[i, j] -> [0, i, 0, j, 0] }"; |
5113 | if (test_one_schedule(ctx, D, W, R, S, 2, 0) < 0) |
5114 | return -1; |
5115 | |
5116 | D = "{ S1[i] : 0 <= i <= 10; S2[i] : 0 <= i <= 9 }"; |
5117 | W = "{ S1[i] -> a[i] }"; |
5118 | R = "{ S2[i] -> a[i+1] }"; |
5119 | S = "{ S1[i] -> [0,i]; S2[i] -> [1,i] }"; |
5120 | if (test_one_schedule(ctx, D, W, R, S, 1, 1) < 0) |
5121 | return -1; |
5122 | |
5123 | D = "{ S1[i] : 0 <= i < 10; S2[i] : 0 <= i < 10 }"; |
5124 | W = "{ S1[i] -> a[i] }"; |
5125 | R = "{ S2[i] -> a[9-i] }"; |
5126 | S = "{ S1[i] -> [0,i]; S2[i] -> [1,i] }"; |
5127 | if (test_one_schedule(ctx, D, W, R, S, 1, 1) < 0) |
5128 | return -1; |
5129 | |
5130 | D = "[N] -> { S1[i] : 0 <= i < N; S2[i] : 0 <= i < N }"; |
5131 | W = "{ S1[i] -> a[i] }"; |
5132 | R = "[N] -> { S2[i] -> a[N-1-i] }"; |
5133 | S = "{ S1[i] -> [0,i]; S2[i] -> [1,i] }"; |
5134 | if (test_one_schedule(ctx, D, W, R, S, 1, 1) < 0) |
5135 | return -1; |
5136 | |
5137 | D = "{ S1[i] : 0 < i < 10; S2[i] : 0 <= i < 10 }"; |
5138 | W = "{ S1[i] -> a[i]; S2[i] -> b[i] }"; |
5139 | R = "{ S2[i] -> a[i]; S1[i] -> b[i-1] }"; |
5140 | S = "{ S1[i] -> [i,0]; S2[i] -> [i,1] }"; |
5141 | if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0) |
5142 | return -1; |
5143 | |
5144 | D = "[N] -> { S1[i] : 1 <= i <= N; S2[i,j] : 1 <= i,j <= N }"; |
5145 | W = "{ S1[i] -> a[0,i]; S2[i,j] -> a[i,j] }"; |
5146 | R = "{ S2[i,j] -> a[i-1,j] }"; |
5147 | S = "{ S1[i] -> [0,i,0]; S2[i,j] -> [1,i,j] }"; |
5148 | if (test_one_schedule(ctx, D, W, R, S, 2, 1) < 0) |
5149 | return -1; |
5150 | |
5151 | D = "[N] -> { S1[i] : 1 <= i <= N; S2[i,j] : 1 <= i,j <= N }"; |
5152 | W = "{ S1[i] -> a[i,0]; S2[i,j] -> a[i,j] }"; |
5153 | R = "{ S2[i,j] -> a[i,j-1] }"; |
5154 | S = "{ S1[i] -> [0,i,0]; S2[i,j] -> [1,i,j] }"; |
5155 | if (test_one_schedule(ctx, D, W, R, S, 2, 1) < 0) |
5156 | return -1; |
5157 | |
5158 | D = "[N] -> { S_0[]; S_1[i] : i >= 0 and i <= -1 + N; S_2[] }"; |
5159 | W = "[N] -> { S_0[] -> a[0]; S_2[] -> b[0]; " |
5160 | "S_1[i] -> a[1 + i] : i >= 0 and i <= -1 + N }"; |
5161 | R = "[N] -> { S_2[] -> a[N]; S_1[i] -> a[i] : i >= 0 and i <= -1 + N }"; |
5162 | S = "[N] -> { S_1[i] -> [1, i, 0]; S_2[] -> [2, 0, 1]; " |
5163 | "S_0[] -> [0, 0, 0] }"; |
5164 | if (test_one_schedule(ctx, D, W, R, S, 1, 0) < 0) |
5165 | return -1; |
5166 | ctx->opt->schedule_parametric = 0; |
5167 | if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0) |
5168 | return -1; |
5169 | ctx->opt->schedule_parametric = 1; |
5170 | |
5171 | D = "[N] -> { S1[i] : 1 <= i <= N; S2[i] : 1 <= i <= N; " |
5172 | "S3[i,j] : 1 <= i,j <= N; S4[i] : 1 <= i <= N }"; |
5173 | W = "{ S1[i] -> a[i,0]; S2[i] -> a[0,i]; S3[i,j] -> a[i,j] }"; |
5174 | R = "[N] -> { S3[i,j] -> a[i-1,j]; S3[i,j] -> a[i,j-1]; " |
5175 | "S4[i] -> a[i,N] }"; |
5176 | S = "{ S1[i] -> [0,i,0]; S2[i] -> [1,i,0]; S3[i,j] -> [2,i,j]; " |
5177 | "S4[i] -> [4,i,0] }"; |
5178 | max_coincidence = isl_options_get_schedule_maximize_coincidence(ctx); |
5179 | isl_options_set_schedule_maximize_coincidence(ctx, 0); |
5180 | if (test_one_schedule(ctx, D, W, R, S, 2, 0) < 0) |
5181 | return -1; |
5182 | isl_options_set_schedule_maximize_coincidence(ctx, max_coincidence); |
5183 | |
5184 | D = "[N] -> { S_0[i, j] : i >= 1 and i <= N and j >= 1 and j <= N }"; |
5185 | W = "[N] -> { S_0[i, j] -> s[0] : i >= 1 and i <= N and j >= 1 and " |
5186 | "j <= N }"; |
5187 | R = "[N] -> { S_0[i, j] -> s[0] : i >= 1 and i <= N and j >= 1 and " |
5188 | "j <= N; " |
5189 | "S_0[i, j] -> a[i, j] : i >= 1 and i <= N and j >= 1 and " |
5190 | "j <= N }"; |
5191 | S = "[N] -> { S_0[i, j] -> [0, i, 0, j, 0] }"; |
5192 | if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0) |
5193 | return -1; |
5194 | |
5195 | D = "[N] -> { S_0[t] : t >= 0 and t <= -1 + N; " |
5196 | " S_2[t] : t >= 0 and t <= -1 + N; " |
5197 | " S_1[t, i] : t >= 0 and t <= -1 + N and i >= 0 and " |
5198 | "i <= -1 + N }"; |
5199 | W = "[N] -> { S_0[t] -> a[t, 0] : t >= 0 and t <= -1 + N; " |
5200 | " S_2[t] -> b[t] : t >= 0 and t <= -1 + N; " |
5201 | " S_1[t, i] -> a[t, 1 + i] : t >= 0 and t <= -1 + N and " |
5202 | "i >= 0 and i <= -1 + N }"; |
5203 | R = "[N] -> { S_1[t, i] -> a[t, i] : t >= 0 and t <= -1 + N and " |
5204 | "i >= 0 and i <= -1 + N; " |
5205 | " S_2[t] -> a[t, N] : t >= 0 and t <= -1 + N }"; |
5206 | S = "[N] -> { S_2[t] -> [0, t, 2]; S_1[t, i] -> [0, t, 1, i, 0]; " |
5207 | " S_0[t] -> [0, t, 0] }"; |
5208 | |
5209 | if (test_one_schedule(ctx, D, W, R, S, 2, 1) < 0) |
5210 | return -1; |
5211 | ctx->opt->schedule_parametric = 0; |
5212 | if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0) |
5213 | return -1; |
5214 | ctx->opt->schedule_parametric = 1; |
5215 | |
5216 | D = "[N] -> { S1[i,j] : 0 <= i,j < N; S2[i,j] : 0 <= i,j < N }"; |
5217 | S = "{ S1[i,j] -> [0,i,j]; S2[i,j] -> [1,i,j] }"; |
5218 | if (test_one_schedule(ctx, D, "{}", "{}", S, 2, 2) < 0) |
5219 | return -1; |
5220 | |
5221 | D = "[M, N] -> { S_1[i] : i >= 0 and i <= -1 + M; " |
5222 | "S_0[i, j] : i >= 0 and i <= -1 + M and j >= 0 and j <= -1 + N }"; |
5223 | W = "[M, N] -> { S_0[i, j] -> a[j] : i >= 0 and i <= -1 + M and " |
5224 | "j >= 0 and j <= -1 + N; " |
5225 | "S_1[i] -> b[0] : i >= 0 and i <= -1 + M }"; |
5226 | R = "[M, N] -> { S_0[i, j] -> a[0] : i >= 0 and i <= -1 + M and " |
5227 | "j >= 0 and j <= -1 + N; " |
5228 | "S_1[i] -> b[0] : i >= 0 and i <= -1 + M }"; |
5229 | S = "[M, N] -> { S_1[i] -> [1, i, 0]; S_0[i, j] -> [0, i, 0, j, 0] }"; |
5230 | if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0) |
5231 | return -1; |
5232 | |
5233 | D = "{ S_0[i] : i >= 0 }"; |
5234 | W = "{ S_0[i] -> a[i] : i >= 0 }"; |
5235 | R = "{ S_0[i] -> a[0] : i >= 0 }"; |
5236 | S = "{ S_0[i] -> [0, i, 0] }"; |
5237 | if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0) |
5238 | return -1; |
5239 | |
5240 | D = "{ S_0[i] : i >= 0; S_1[i] : i >= 0 }"; |
5241 | W = "{ S_0[i] -> a[i] : i >= 0; S_1[i] -> b[i] : i >= 0 }"; |
5242 | R = "{ S_0[i] -> b[0] : i >= 0; S_1[i] -> a[i] : i >= 0 }"; |
5243 | S = "{ S_1[i] -> [0, i, 1]; S_0[i] -> [0, i, 0] }"; |
5244 | if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0) |
5245 | return -1; |
5246 | |
5247 | D = "[n] -> { S_0[j, k] : j <= -1 + n and j >= 0 and " |
5248 | "k <= -1 + n and k >= 0 }"; |
5249 | W = "[n] -> { S_0[j, k] -> B[j] : j <= -1 + n and j >= 0 and " "k <= -1 + n and k >= 0 }"; |
5250 | R = "[n] -> { S_0[j, k] -> B[j] : j <= -1 + n and j >= 0 and " |
5251 | "k <= -1 + n and k >= 0; " |
5252 | "S_0[j, k] -> B[k] : j <= -1 + n and j >= 0 and " |
5253 | "k <= -1 + n and k >= 0; " |
5254 | "S_0[j, k] -> A[k] : j <= -1 + n and j >= 0 and " |
5255 | "k <= -1 + n and k >= 0 }"; |
5256 | S = "[n] -> { S_0[j, k] -> [2, j, k] }"; |
5257 | ctx->opt->schedule_outer_coincidence = 1; |
5258 | if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0) |
5259 | return -1; |
5260 | ctx->opt->schedule_outer_coincidence = 0; |
5261 | |
5262 | D = "{Stmt_for_body24[i0, i1, i2, i3]:" |
5263 | "i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 6 and i2 >= 2 and " |
5264 | "i2 <= 6 - i1 and i3 >= 0 and i3 <= -1 + i2;" |
5265 | "Stmt_for_body24[i0, i1, 1, 0]:" |
5266 | "i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 5;" |
5267 | "Stmt_for_body7[i0, i1, i2]:" |
5268 | "i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 7 and i2 >= 0 and " |
5269 | "i2 <= 7 }"; |
5270 | |
5271 | V = "{Stmt_for_body24[0, i1, i2, i3] -> " |
5272 | "Stmt_for_body24[1, i1, i2, i3]:" |
5273 | "i3 >= 0 and i3 <= -1 + i2 and i1 >= 0 and i2 <= 6 - i1 and " |
5274 | "i2 >= 1;" |
5275 | "Stmt_for_body24[0, i1, i2, i3] -> " |
5276 | "Stmt_for_body7[1, 1 + i1 + i3, 1 + i1 + i2]:" |
5277 | "i3 <= -1 + i2 and i2 <= 6 - i1 and i2 >= 1 and i1 >= 0 and " |
5278 | "i3 >= 0;" |
5279 | "Stmt_for_body24[0, i1, i2, i3] ->" |
5280 | "Stmt_for_body7[1, i1, 1 + i1 + i3]:" |
5281 | "i3 >= 0 and i2 <= 6 - i1 and i1 >= 0 and i3 <= -1 + i2;" |
5282 | "Stmt_for_body7[0, i1, i2] -> Stmt_for_body7[1, i1, i2]:" |
5283 | "(i2 >= 1 + i1 and i2 <= 6 and i1 >= 0 and i1 <= 4) or " |
5284 | "(i2 >= 3 and i2 <= 7 and i1 >= 1 and i2 >= 1 + i1) or " |
5285 | "(i2 >= 0 and i2 <= i1 and i2 >= -7 + i1 and i1 <= 7);" |
5286 | "Stmt_for_body7[0, i1, 1 + i1] -> Stmt_for_body7[1, i1, 1 + i1]:" |
5287 | "i1 <= 6 and i1 >= 0;" |
5288 | "Stmt_for_body7[0, 0, 7] -> Stmt_for_body7[1, 0, 7];" |
5289 | "Stmt_for_body7[i0, i1, i2] -> " |
5290 | "Stmt_for_body24[i0, o1, -1 + i2 - o1, -1 + i1 - o1]:" |
5291 | "i0 >= 0 and i0 <= 1 and o1 >= 0 and i2 >= 1 + i1 and " |
5292 | "o1 <= -2 + i2 and i2 <= 7 and o1 <= -1 + i1;" |
5293 | "Stmt_for_body7[i0, i1, i2] -> " |
5294 | "Stmt_for_body24[i0, i1, o2, -1 - i1 + i2]:" |
5295 | "i0 >= 0 and i0 <= 1 and i1 >= 0 and o2 >= -i1 + i2 and " |
5296 | "o2 >= 1 and o2 <= 6 - i1 and i2 >= 1 + i1 }"; |
5297 | P = V; |
5298 | |
5299 | treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx); |
5300 | isl_options_set_schedule_treat_coalescing(ctx, 0); |
5301 | if (test_has_schedule(ctx, D, V, P) < 0) |
5302 | return -1; |
5303 | isl_options_set_schedule_treat_coalescing(ctx, treat_coalescing); |
5304 | |
5305 | D = "{ S_0[i, j] : i >= 1 and i <= 10 and j >= 1 and j <= 8 }"; |
5306 | V = "{ S_0[i, j] -> S_0[i, 1 + j] : i >= 1 and i <= 10 and " |
5307 | "j >= 1 and j <= 7;" |
5308 | "S_0[i, j] -> S_0[1 + i, j] : i >= 1 and i <= 9 and " |
5309 | "j >= 1 and j <= 8 }"; |
5310 | P = "{ }"; |
5311 | S = "{ S_0[i, j] -> [i + j, i] }"; |
5312 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1; |
5313 | if (test_special_schedule(ctx, D, V, P, S) < 0) |
5314 | return -1; |
5315 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0; |
5316 | |
5317 | /* Fig. 1 from Feautrier's "Some Efficient Solutions..." pt. 2, 1992 */ |
5318 | D = "[N] -> { S_0[i, j] : i >= 0 and i <= -1 + N and " |
5319 | "j >= 0 and j <= -1 + i }"; |
5320 | V = "[N] -> { S_0[i, j] -> S_0[i, 1 + j] : j <= -2 + i and " |
5321 | "i <= -1 + N and j >= 0;" |
5322 | "S_0[i, -1 + i] -> S_0[1 + i, 0] : i >= 1 and " |
5323 | "i <= -2 + N }"; |
5324 | P = "{ }"; |
5325 | S = "{ S_0[i, j] -> [i, j] }"; |
5326 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1; |
5327 | if (test_special_schedule(ctx, D, V, P, S) < 0) |
5328 | return -1; |
5329 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0; |
5330 | |
5331 | /* Test both algorithms on a case with only proximity dependences. */ |
5332 | D = "{ S[i,j] : 0 <= i <= 10 }"; |
5333 | V = "{ }"; |
5334 | P = "{ S[i,j] -> S[i+1,j] : 0 <= i,j <= 10 }"; |
5335 | S = "{ S[i, j] -> [j, i] }"; |
5336 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1; |
5337 | if (test_special_schedule(ctx, D, V, P, S) < 0) |
5338 | return -1; |
5339 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0; |
5340 | if (test_special_schedule(ctx, D, V, P, S) < 0) |
5341 | return -1; |
5342 | |
5343 | D = "{ A[a]; B[] }"; |
5344 | V = "{}"; |
5345 | P = "{ A[a] -> B[] }"; |
5346 | if (test_has_schedule(ctx, D, V, P) < 0) |
5347 | return -1; |
5348 | |
5349 | if (test_padded_schedule(ctx) < 0) |
5350 | return -1; |
5351 | |
5352 | /* Check that check for progress is not confused by rational |
5353 | * solution. |
5354 | */ |
5355 | D = "[N] -> { S0[i, j] : i >= 0 and i <= N and j >= 0 and j <= N }"; |
5356 | V = "[N] -> { S0[i0, -1 + N] -> S0[2 + i0, 0] : i0 >= 0 and " |
5357 | "i0 <= -2 + N; " |
5358 | "S0[i0, i1] -> S0[i0, 1 + i1] : i0 >= 0 and " |
5359 | "i0 <= N and i1 >= 0 and i1 <= -1 + N }"; |
5360 | P = "{}"; |
5361 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1; |
5362 | if (test_has_schedule(ctx, D, V, P) < 0) |
5363 | return -1; |
5364 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0; |
5365 | |
5366 | /* Check that we allow schedule rows that are only non-trivial |
5367 | * on some full-dimensional domains. |
5368 | */ |
5369 | D = "{ S1[j] : 0 <= j <= 1; S0[]; S2[k] : 0 <= k <= 1 }"; |
5370 | V = "{ S0[] -> S1[j] : 0 <= j <= 1; S2[0] -> S0[];" |
5371 | "S1[j] -> S2[1] : 0 <= j <= 1 }"; |
5372 | P = "{}"; |
5373 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1; |
5374 | if (test_has_schedule(ctx, D, V, P) < 0) |
5375 | return -1; |
5376 | ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0; |
5377 | |
5378 | if (test_conditional_schedule_constraints(ctx) < 0) |
5379 | return -1; |
5380 | |
5381 | if (test_strongly_satisfying_schedule(ctx) < 0) |
5382 | return -1; |
5383 | |
5384 | if (test_conflicting_context_schedule(ctx) < 0) |
5385 | return -1; |
5386 | |
5387 | if (test_coalescing_schedule(ctx) < 0) |
5388 | return -1; |
5389 | if (test_skewing_schedule(ctx) < 0) |
5390 | return -1; |
5391 | |
5392 | return 0; |
5393 | } |
5394 | |
5395 | /* Perform scheduling tests using the whole component scheduler. |
5396 | */ |
5397 | static int test_schedule_whole(isl_ctx *ctx) |
5398 | { |
5399 | int whole; |
5400 | int r; |
5401 | |
5402 | whole = isl_options_get_schedule_whole_component(ctx); |
5403 | isl_options_set_schedule_whole_component(ctx, 1); |
5404 | r = test_schedule(ctx); |
5405 | isl_options_set_schedule_whole_component(ctx, whole); |
5406 | |
5407 | return r; |
5408 | } |
5409 | |
5410 | /* Perform scheduling tests using the incremental scheduler. |
5411 | */ |
5412 | static int test_schedule_incremental(isl_ctx *ctx) |
5413 | { |
5414 | int whole; |
5415 | int r; |
5416 | |
5417 | whole = isl_options_get_schedule_whole_component(ctx); |
5418 | isl_options_set_schedule_whole_component(ctx, 0); |
5419 | r = test_schedule(ctx); |
5420 | isl_options_set_schedule_whole_component(ctx, whole); |
5421 | |
5422 | return r; |
5423 | } |
5424 | |
5425 | int test_plain_injective(isl_ctx *ctx, const char *str, int injective) |
5426 | { |
5427 | isl_union_map *umap; |
5428 | int test; |
5429 | |
5430 | umap = isl_union_map_read_from_str(ctx, str); |
5431 | test = isl_union_map_plain_is_injective(umap); |
5432 | isl_union_map_free(umap); |
5433 | if (test < 0) |
5434 | return -1; |
5435 | if (test == injective) |
5436 | return 0; |
5437 | if (injective) |
5438 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "map not detected as injective" , "polly/lib/External/isl/isl_test.c", 5439); return -1; } while (0) |
5439 | "map not detected as injective", return -1)do { isl_handle_error(ctx, isl_error_unknown, "map not detected as injective" , "polly/lib/External/isl/isl_test.c", 5439); return -1; } while (0); |
5440 | else |
5441 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "map detected as injective" , "polly/lib/External/isl/isl_test.c", 5442); return -1; } while (0) |
5442 | "map detected as injective", return -1)do { isl_handle_error(ctx, isl_error_unknown, "map detected as injective" , "polly/lib/External/isl/isl_test.c", 5442); return -1; } while (0); |
5443 | } |
5444 | |
5445 | int test_injective(isl_ctx *ctx) |
5446 | { |
5447 | const char *str; |
5448 | |
5449 | if (test_plain_injective(ctx, "{S[i,j] -> A[0]; T[i,j] -> B[1]}", 0)) |
5450 | return -1; |
5451 | if (test_plain_injective(ctx, "{S[] -> A[0]; T[] -> B[0]}", 1)) |
5452 | return -1; |
5453 | if (test_plain_injective(ctx, "{S[] -> A[0]; T[] -> A[1]}", 1)) |
5454 | return -1; |
5455 | if (test_plain_injective(ctx, "{S[] -> A[0]; T[] -> A[0]}", 0)) |
5456 | return -1; |
5457 | if (test_plain_injective(ctx, "{S[i] -> A[i,0]; T[i] -> A[i,1]}", 1)) |
5458 | return -1; |
5459 | if (test_plain_injective(ctx, "{S[i] -> A[i]; T[i] -> A[i]}", 0)) |
5460 | return -1; |
5461 | if (test_plain_injective(ctx, "{S[] -> A[0,0]; T[] -> A[0,1]}", 1)) |
5462 | return -1; |
5463 | if (test_plain_injective(ctx, "{S[] -> A[0,0]; T[] -> A[1,0]}", 1)) |
5464 | return -1; |
5465 | |
5466 | str = "{S[] -> A[0,0]; T[] -> A[0,1]; U[] -> A[1,0]}"; |
5467 | if (test_plain_injective(ctx, str, 1)) |
5468 | return -1; |
5469 | str = "{S[] -> A[0,0]; T[] -> A[0,1]; U[] -> A[0,0]}"; |
5470 | if (test_plain_injective(ctx, str, 0)) |
5471 | return -1; |
5472 | |
5473 | return 0; |
5474 | } |
5475 | |
5476 | #undef BASEunion_pw_qpolynomial |
5477 | #define BASEunion_pw_qpolynomial aff |
5478 | #include "isl_test_plain_equal_templ.c" |
5479 | |
5480 | #undef BASEunion_pw_qpolynomial |
5481 | #define BASEunion_pw_qpolynomial pw_multi_aff |
5482 | #include "isl_test_plain_equal_templ.c" |
5483 | |
5484 | #undef BASEunion_pw_qpolynomial |
5485 | #define BASEunion_pw_qpolynomial union_pw_aff |
5486 | #include "isl_test_plain_equal_templ.c" |
5487 | |
5488 | /* Basic tests on isl_union_pw_aff. |
5489 | * |
5490 | * In particular, check that isl_union_pw_aff_aff_on_domain |
5491 | * aligns the parameters of the input objects and |
5492 | * that isl_union_pw_aff_param_on_domain_id properly |
5493 | * introduces the parameter. |
5494 | */ |
5495 | static int test_upa(isl_ctx *ctx) |
5496 | { |
5497 | const char *str; |
5498 | isl_id *id; |
5499 | isl_aff *aff; |
5500 | isl_union_set *domain; |
5501 | isl_union_pw_aff *upa; |
5502 | isl_stat ok; |
5503 | |
5504 | aff = isl_aff_read_from_str(ctx, "[N] -> { [N] }"); |
5505 | str = "[M] -> { A[i] : 0 <= i < M; B[] }"; |
5506 | domain = isl_union_set_read_from_str(ctx, str); |
5507 | upa = isl_union_pw_aff_aff_on_domain(domain, aff); |
5508 | str = "[N, M] -> { A[i] -> [N] : 0 <= i < M; B[] -> [N] }"; |
5509 | ok = union_pw_aff_check_plain_equal(upa, str); |
5510 | isl_union_pw_aff_free(upa); |
5511 | if (ok < 0) |
5512 | return -1; |
5513 | |
5514 | id = isl_id_alloc(ctx, "N", NULL((void*)0)); |
5515 | str = "[M] -> { A[i] : 0 <= i < M; B[] }"; |
5516 | domain = isl_union_set_read_from_str(ctx, str); |
5517 | upa = isl_union_pw_aff_param_on_domain_id(domain, id); |
5518 | str = "[N, M] -> { A[i] -> [N] : 0 <= i < M; B[] -> [N] }"; |
5519 | ok = union_pw_aff_check_plain_equal(upa, str); |
5520 | isl_union_pw_aff_free(upa); |
5521 | if (ok < 0) |
5522 | return -1; |
5523 | |
5524 | return 0; |
5525 | } |
5526 | |
5527 | struct { |
5528 | __isl_give isl_aff *(*fn)(__isl_take isl_aff *aff1, |
5529 | __isl_take isl_aff *aff2); |
5530 | } aff_bin_op[] = { |
5531 | ['+'] = { &isl_aff_add }, |
5532 | ['-'] = { &isl_aff_sub }, |
5533 | ['*'] = { &isl_aff_mul }, |
5534 | ['/'] = { &isl_aff_div }, |
5535 | }; |
5536 | |
5537 | struct { |
5538 | const char *arg1; |
5539 | unsigned char op; |
5540 | const char *arg2; |
5541 | const char *res; |
5542 | } aff_bin_tests[] = { |
5543 | { "{ [i] -> [i] }", '+', "{ [i] -> [i] }", |
5544 | "{ [i] -> [2i] }" }, |
5545 | { "{ [i] -> [i] }", '-', "{ [i] -> [i] }", |
5546 | "{ [i] -> [0] }" }, |
5547 | { "{ [i] -> [i] }", '*', "{ [i] -> [2] }", |
5548 | "{ [i] -> [2i] }" }, |
5549 | { "{ [i] -> [2] }", '*', "{ [i] -> [i] }", |
5550 | "{ [i] -> [2i] }" }, |
5551 | { "{ [i] -> [i] }", '/', "{ [i] -> [2] }", |
5552 | "{ [i] -> [i/2] }" }, |
5553 | { "{ [i] -> [2i] }", '/', "{ [i] -> [2] }", |
5554 | "{ [i] -> [i] }" }, |
5555 | { "{ [i] -> [i] }", '+', "{ [i] -> [NaN] }", |
5556 | "{ [i] -> [NaN] }" }, |
5557 | { "{ [i] -> [i] }", '-', "{ [i] -> [NaN] }", |
5558 | "{ [i] -> [NaN] }" }, |
5559 | { "{ [i] -> [i] }", '*', "{ [i] -> [NaN] }", |
5560 | "{ [i] -> [NaN] }" }, |
5561 | { "{ [i] -> [2] }", '*', "{ [i] -> [NaN] }", |
5562 | "{ [i] -> [NaN] }" }, |
5563 | { "{ [i] -> [i] }", '/', "{ [i] -> [NaN] }", |
5564 | "{ [i] -> [NaN] }" }, |
5565 | { "{ [i] -> [2] }", '/', "{ [i] -> [NaN] }", |
5566 | "{ [i] -> [NaN] }" }, |
5567 | { "{ [i] -> [NaN] }", '+', "{ [i] -> [i] }", |
5568 | "{ [i] -> [NaN] }" }, |
5569 | { "{ [i] -> [NaN] }", '-', "{ [i] -> [i] }", |
5570 | "{ [i] -> [NaN] }" }, |
5571 | { "{ [i] -> [NaN] }", '*', "{ [i] -> [2] }", |
5572 | "{ [i] -> [NaN] }" }, |
5573 | { "{ [i] -> [NaN] }", '*', "{ [i] -> [i] }", |
5574 | "{ [i] -> [NaN] }" }, |
5575 | { "{ [i] -> [NaN] }", '/', "{ [i] -> [2] }", |
5576 | "{ [i] -> [NaN] }" }, |
5577 | { "{ [i] -> [NaN] }", '/', "{ [i] -> [i] }", |
5578 | "{ [i] -> [NaN] }" }, |
5579 | { "{ [i] -> [i] }", '/', "{ [i] -> [0] }", |
5580 | "{ [i] -> [NaN] }" }, |
5581 | }; |
5582 | |
5583 | /* Perform some basic tests of binary operations on isl_aff objects. |
5584 | */ |
5585 | static int test_bin_aff(isl_ctx *ctx) |
5586 | { |
5587 | int i; |
5588 | isl_aff *aff1, *aff2, *res; |
5589 | __isl_give isl_aff *(*fn)(__isl_take isl_aff *aff1, |
5590 | __isl_take isl_aff *aff2); |
5591 | int ok; |
5592 | |
5593 | for (i = 0; i < ARRAY_SIZE(aff_bin_tests)(sizeof(aff_bin_tests)/sizeof(*aff_bin_tests)); ++i) { |
5594 | aff1 = isl_aff_read_from_str(ctx, aff_bin_tests[i].arg1); |
5595 | aff2 = isl_aff_read_from_str(ctx, aff_bin_tests[i].arg2); |
5596 | res = isl_aff_read_from_str(ctx, aff_bin_tests[i].res); |
5597 | fn = aff_bin_op[aff_bin_tests[i].op].fn; |
5598 | aff1 = fn(aff1, aff2); |
5599 | if (isl_aff_is_nan(res)) |
5600 | ok = isl_aff_is_nan(aff1); |
5601 | else |
5602 | ok = isl_aff_plain_is_equal(aff1, res); |
5603 | isl_aff_free(aff1); |
5604 | isl_aff_free(res); |
5605 | if (ok < 0) |
5606 | return -1; |
5607 | if (!ok) |
5608 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 5609); return -1; } while (0) |
5609 | "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 5609); return -1; } while (0); |
5610 | } |
5611 | |
5612 | return 0; |
5613 | } |
5614 | |
5615 | struct { |
5616 | __isl_give isl_pw_aff *(*fn)(__isl_take isl_pw_aff *pa1, |
5617 | __isl_take isl_pw_aff *pa2); |
5618 | } pw_aff_bin_op[] = { |
5619 | ['m'] = { &isl_pw_aff_min }, |
5620 | ['M'] = { &isl_pw_aff_max }, |
5621 | }; |
5622 | |
5623 | /* Inputs for binary isl_pw_aff operation tests. |
5624 | * "arg1" and "arg2" are the two arguments, "op" identifies the operation |
5625 | * defined by pw_aff_bin_op, and "res" is the expected result. |
5626 | */ |
5627 | struct { |
5628 | const char *arg1; |
5629 | unsigned char op; |
5630 | const char *arg2; |
5631 | const char *res; |
5632 | } pw_aff_bin_tests[] = { |
5633 | { "{ [i] -> [i] }", 'm', "{ [i] -> [i] }", |
5634 | "{ [i] -> [i] }" }, |
5635 | { "{ [i] -> [i] }", 'M', "{ [i] -> [i] }", |
5636 | "{ [i] -> [i] }" }, |
5637 | { "{ [i] -> [i] }", 'm', "{ [i] -> [0] }", |
5638 | "{ [i] -> [i] : i <= 0; [i] -> [0] : i > 0 }" }, |
5639 | { "{ [i] -> [i] }", 'M', "{ [i] -> [0] }", |
5640 | "{ [i] -> [i] : i >= 0; [i] -> [0] : i < 0 }" }, |
5641 | { "{ [i] -> [i] }", 'm', "{ [i] -> [NaN] }", |
5642 | "{ [i] -> [NaN] }" }, |
5643 | { "{ [i] -> [NaN] }", 'm', "{ [i] -> [i] }", |
5644 | "{ [i] -> [NaN] }" }, |
5645 | }; |
5646 | |
5647 | /* Perform some basic tests of binary operations on isl_pw_aff objects. |
5648 | */ |
5649 | static int test_bin_pw_aff(isl_ctx *ctx) |
5650 | { |
5651 | int i; |
5652 | isl_bool ok; |
5653 | isl_pw_aff *pa1, *pa2, *res; |
5654 | |
5655 | for (i = 0; i < ARRAY_SIZE(pw_aff_bin_tests)(sizeof(pw_aff_bin_tests)/sizeof(*pw_aff_bin_tests)); ++i) { |
5656 | pa1 = isl_pw_aff_read_from_str(ctx, pw_aff_bin_tests[i].arg1); |
5657 | pa2 = isl_pw_aff_read_from_str(ctx, pw_aff_bin_tests[i].arg2); |
5658 | res = isl_pw_aff_read_from_str(ctx, pw_aff_bin_tests[i].res); |
5659 | pa1 = pw_aff_bin_op[pw_aff_bin_tests[i].op].fn(pa1, pa2); |
5660 | if (isl_pw_aff_involves_nan(res)) |
5661 | ok = isl_pw_aff_involves_nan(pa1); |
5662 | else |
5663 | ok = isl_pw_aff_plain_is_equal(pa1, res); |
5664 | isl_pw_aff_free(pa1); |
5665 | isl_pw_aff_free(res); |
5666 | if (ok < 0) |
5667 | return -1; |
5668 | if (!ok) |
5669 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 5670); return -1; } while (0) |
5670 | "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 5670); return -1; } while (0); |
5671 | } |
5672 | |
5673 | return 0; |
5674 | } |
5675 | |
5676 | /* Inputs for basic tests of test operations on |
5677 | * isl_union_pw_multi_aff objects. |
5678 | * "fn" is the function that is being tested. |
5679 | * "arg" is a string description of the input. |
5680 | * "res" is the expected result. |
5681 | */ |
5682 | static struct { |
5683 | isl_bool (*fn)(__isl_keep isl_union_pw_multi_aff *upma1); |
5684 | const char *arg; |
5685 | isl_bool res; |
5686 | } upma_test_tests[] = { |
5687 | { &isl_union_pw_multi_aff_involves_nan, "{ A[] -> [0]; B[0] -> [1] }", |
5688 | isl_bool_false }, |
5689 | { &isl_union_pw_multi_aff_involves_nan, "{ A[] -> [NaN]; B[0] -> [1] }", |
5690 | isl_bool_true }, |
5691 | { &isl_union_pw_multi_aff_involves_nan, "{ A[] -> [0]; B[0] -> [NaN] }", |
5692 | isl_bool_true }, |
5693 | { &isl_union_pw_multi_aff_involves_nan, |
5694 | "{ A[] -> [0]; B[0] -> [1, NaN, 5] }", |
5695 | isl_bool_true }, |
5696 | { &isl_union_pw_multi_aff_involves_locals, |
5697 | "{ A[] -> [0]; B[0] -> [1] }", |
5698 | isl_bool_false }, |
5699 | { &isl_union_pw_multi_aff_involves_locals, |
5700 | "{ A[] -> [0]; B[x] -> [1] : x mod 2 = 0 }", |
5701 | isl_bool_true }, |
5702 | { &isl_union_pw_multi_aff_involves_locals, |
5703 | "{ A[] -> [0]; B[x] -> [x // 2] }", |
5704 | isl_bool_true }, |
5705 | { &isl_union_pw_multi_aff_involves_locals, |
5706 | "{ A[i] -> [i // 2]; B[0] -> [1] }", |
5707 | isl_bool_true }, |
5708 | }; |
5709 | |
5710 | /* Perform some basic tests of test operations on |
5711 | * isl_union_pw_multi_aff objects. |
5712 | */ |
5713 | static isl_stat test_upma_test(isl_ctx *ctx) |
5714 | { |
5715 | int i; |
5716 | isl_union_pw_multi_aff *upma; |
5717 | isl_bool res; |
5718 | |
5719 | for (i = 0; i < ARRAY_SIZE(upma_test_tests)(sizeof(upma_test_tests)/sizeof(*upma_test_tests)); ++i) { |
5720 | const char *str; |
5721 | |
5722 | str = upma_test_tests[i].arg; |
5723 | upma = isl_union_pw_multi_aff_read_from_str(ctx, str); |
5724 | res = upma_test_tests[i].fn(upma); |
5725 | isl_union_pw_multi_aff_free(upma); |
5726 | if (res < 0) |
5727 | return isl_stat_error; |
5728 | if (res != upma_test_tests[i].res) |
5729 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 5730); return isl_stat_error ; } while (0) |
5730 | "unexpected result", return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 5730); return isl_stat_error ; } while (0); |
5731 | } |
5732 | |
5733 | return isl_stat_ok; |
5734 | } |
5735 | |
5736 | struct { |
5737 | __isl_give isl_union_pw_multi_aff *(*fn)( |
5738 | __isl_take isl_union_pw_multi_aff *upma1, |
5739 | __isl_take isl_union_pw_multi_aff *upma2); |
5740 | const char *arg1; |
5741 | const char *arg2; |
5742 | const char *res; |
5743 | } upma_bin_tests[] = { |
5744 | { &isl_union_pw_multi_aff_add, "{ A[] -> [0]; B[0] -> [1] }", |
5745 | "{ B[x] -> [2] : x >= 0 }", "{ B[0] -> [3] }" }, |
5746 | { &isl_union_pw_multi_aff_union_add, "{ A[] -> [0]; B[0] -> [1] }", |
5747 | "{ B[x] -> [2] : x >= 0 }", |
5748 | "{ A[] -> [0]; B[0] -> [3]; B[x] -> [2] : x >= 1 }" }, |
5749 | { &isl_union_pw_multi_aff_pullback_union_pw_multi_aff, |
5750 | "{ A[] -> B[0]; C[x] -> B[1] : x < 10; C[y] -> B[2] : y >= 10 }", |
5751 | "{ D[i] -> A[] : i < 0; D[i] -> C[i + 5] : i >= 0 }", |
5752 | "{ D[i] -> B[0] : i < 0; D[i] -> B[1] : 0 <= i < 5; " |
5753 | "D[i] -> B[2] : i >= 5 }" }, |
5754 | { &isl_union_pw_multi_aff_union_add, "{ B[x] -> A[1] : x <= 0 }", |
5755 | "{ B[x] -> C[2] : x > 0 }", |
5756 | "{ B[x] -> A[1] : x <= 0; B[x] -> C[2] : x > 0 }" }, |
5757 | { &isl_union_pw_multi_aff_union_add, "{ B[x] -> A[1] : x <= 0 }", |
5758 | "{ B[x] -> A[2] : x >= 0 }", |
5759 | "{ B[x] -> A[1] : x < 0; B[x] -> A[2] : x > 0; B[0] -> A[3] }" }, |
5760 | { |
5761 | &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff, |
5762 | "{ B[x] -> C[x + 2] }", |
5763 | "{ D[y] -> B[2y] }", |
5764 | "{ }" }, |
5765 | { |
5766 | &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff, |
5767 | "{ [A[x] -> B[x + 1]] -> C[x + 2] }", |
5768 | "{ D[y] -> B[2y] }", |
5769 | "{ }" }, |
5770 | { |
5771 | &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff, |
5772 | "{ [A[x] -> B[x + 1]] -> C[x + 2]; B[x] -> C[x + 2] }", |
5773 | "{ D[y] -> A[2y] }", |
5774 | "{ [D[y] -> B[2y + 1]] -> C[2y + 2] }" }, |
5775 | { |
5776 | &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff, |
5777 | "{ T[A[x] -> B[x + 1]] -> C[x + 2]; B[x] -> C[x + 2] }", |
5778 | "{ D[y] -> A[2y] }", |
5779 | "{ T[D[y] -> B[2y + 1]] -> C[2y + 2] }" }, |
5780 | }; |
5781 | |
5782 | /* Perform some basic tests of binary operations on |
5783 | * isl_union_pw_multi_aff objects. |
5784 | */ |
5785 | static int test_bin_upma(isl_ctx *ctx) |
5786 | { |
5787 | int i; |
5788 | isl_union_pw_multi_aff *upma1, *upma2, *res; |
5789 | int ok; |
5790 | |
5791 | for (i = 0; i < ARRAY_SIZE(upma_bin_tests)(sizeof(upma_bin_tests)/sizeof(*upma_bin_tests)); ++i) { |
5792 | upma1 = isl_union_pw_multi_aff_read_from_str(ctx, |
5793 | upma_bin_tests[i].arg1); |
5794 | upma2 = isl_union_pw_multi_aff_read_from_str(ctx, |
5795 | upma_bin_tests[i].arg2); |
5796 | res = isl_union_pw_multi_aff_read_from_str(ctx, |
5797 | upma_bin_tests[i].res); |
5798 | upma1 = upma_bin_tests[i].fn(upma1, upma2); |
5799 | ok = isl_union_pw_multi_aff_plain_is_equal(upma1, res); |
5800 | isl_union_pw_multi_aff_free(upma1); |
5801 | isl_union_pw_multi_aff_free(res); |
5802 | if (ok < 0) |
5803 | return -1; |
5804 | if (!ok) |
5805 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 5806); return -1; } while (0) |
5806 | "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result" , "polly/lib/External/isl/isl_test.c", 5806); return -1; } while (0); |
5807 | } |
5808 | |
5809 | return 0; |
5810 | } |
5811 | |
5812 | struct { |
5813 | __isl_give isl_union_pw_multi_aff *(*fn)( |
5814 | __isl_take isl_union_pw_multi_aff *upma1, |
5815 | __isl_take isl_union_pw_multi_aff *upma2); |
5816 | const char *arg1; |
5817 | const char *arg2; |
5818 | } upma_bin_fail_tests[] = { |
5819 | { &isl_union_pw_multi_aff_union_add, "{ B[x] -> A[1] : x <= 0 }", |
5820 | "{ B[x] -> C[2] : x >= 0 }" }, |
5821 | }; |
5822 | |
5823 | /* Perform some basic tests of binary operations on |
5824 | * isl_union_pw_multi_aff objects that are expected to fail. |
5825 | */ |
5826 | static int test_bin_upma_fail(isl_ctx *ctx) |
5827 | { |
5828 | int i, n; |
5829 | isl_union_pw_multi_aff *upma1, *upma2; |
5830 | int on_error; |
5831 | |
5832 | on_error = isl_options_get_on_error(ctx); |
5833 | isl_options_set_on_error(ctx, ISL_ON_ERROR_CONTINUE1); |
5834 | n = ARRAY_SIZE(upma_bin_fail_tests)(sizeof(upma_bin_fail_tests)/sizeof(*upma_bin_fail_tests)); |
5835 | for (i = 0; i < n; ++i) { |
5836 | upma1 = isl_union_pw_multi_aff_read_from_str(ctx, |
5837 | upma_bin_fail_tests[i].arg1); |
5838 | upma2 = isl_union_pw_multi_aff_read_from_str(ctx, |
5839 | upma_bin_fail_tests[i].arg2); |
5840 | upma1 = upma_bin_fail_tests[i].fn(upma1, upma2); |
5841 | isl_union_pw_multi_aff_free(upma1); |
5842 | if (upma1) |
5843 | break; |
5844 | } |
5845 | isl_options_set_on_error(ctx, on_error); |
5846 | if (i < n) |
5847 | isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed" , "polly/lib/External/isl/isl_test.c", 5848); return -1; } while (0) |
5848 | "operation not expected to succeed", return -1)do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed" , "polly/lib/External/isl/isl_test.c", 5848); return -1; } while (0); |
5849 | |
5850 | return 0; |
5851 | } |
5852 | |
5853 | /* Inputs for basic tests of binary operations on |
5854 | * pairs of isl_union_pw_multi_aff and isl_union_set objects. |
5855 | * "fn" is the function that is being tested. |
5856 | * "arg1" and "arg2" are string descriptions of the inputs. |
5857 | * "res" is a string description of the expected result. |
5858 | */ |
5859 | struct { |
5860 | __isl_give isl_union_pw_multi_aff *(*fn)( |
5861 | __isl_take isl_union_pw_multi_aff *upma, |
5862 | __isl_take isl_union_set *uset); |
5863 | const char *arg1; |
5864 | const char *arg2; |
5865 | const char *res; |
5866 | } upma_uset_tests[] = { |
5867 | { &isl_union_pw_multi_aff_intersect_domain_wrapped_range, |
5868 | "{ A[i] -> B[i] }", "{ B[0] }", |
5869 | "{ }" }, |
5870 | { &isl_union_pw_multi_aff_intersect_domain_wrapped_domain, |
5871 | "{ [A[i] -> B[i]] -> C[i + 1] }", "{ A[1]; B[0] }", |
5872 | "{ [A[1] -> B[1]] -> C[2] }" }, |
5873 | { &isl_union_pw_multi_aff_intersect_domain_wrapped_range, |
5874 | "{ [A[i] -> B[i]] -> C[i + 1] }", "{ A[1]; B[0] }", |
5875 | "{ [A[0] -> B[0]] -> C[1] }" }, |
5876 | { &isl_union_pw_multi_aff_intersect_domain_wrapped_range, |
5877 | "{ [A[i] -> B[i]] -> C[i + 1] }", "[N] -> { B[N] }", |
5878 | "[N] -> { [A[N] -> B[N]] -> C[N + 1] }" }, |
5879 | { &isl_union_pw_multi_aff_intersect_domain_wrapped_range, |
5880 | "[M] -> { [A[M] -> B[M]] -> C[M + 1] }", |