Bug Summary

File:build/source/polly/lib/External/isl/isl_test.c
Warning:line 8024, column 12
The left operand of '<' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name isl_test.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=../../../../ -fdebug-prefix-map=/build/source/= -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-19/lib/clang/19 -I tools/polly/lib/External -I /build/source/polly/lib/External -I /build/source/polly/lib/External/isl -I /build/source/polly/lib/External/isl/include -I /build/source/polly/lib/External/isl/imath -I tools/polly/lib/External/isl -I tools/polly/include -I /build/source/polly/lib/External/pet/include -I tools/polly/lib/External/isl/include -I /build/source/polly/include -I include -I /build/source/llvm/include -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=../../../../ -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=../../../../ -fcoverage-prefix-map=/build/source/= -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=gnu99 -fconst-strings -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-01-26-042103-19840-1 -x c /build/source/polly/lib/External/isl/isl_test.c
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
49static 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
66void 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
75int 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
95void 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
104static 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 */
115static 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 */
128static 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 */
153static 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 */
163static 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 */
186static 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 */
205static 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 */
219static 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 */
237static 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 */
281static 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 */
308static 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 */
346static 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 */
359struct {
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
477int 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
545static 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
578static 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 } */
618static 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 */
649static 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 */
679static 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
688static 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 */
745static 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
772struct {
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 */
828static 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
849struct {
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
862struct {
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 */
948static 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 */
980static 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 */
992static 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 */
1001static 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
1021static 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
1291void 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
1319static 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
1327void 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 */
1355struct {
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 */
1367static 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
1395int 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 */
1456static 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 */
1482struct {
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 */
1506static 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
1533static 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 */
1567static 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 */
1587static 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
1619void 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
1648struct {
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
1674static 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
1720static 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 */
1733static 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 */
1764static 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 */
1782struct {
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 */
1801static 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 */
1831struct {
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 */
1843static 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
1872struct {
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 */
1960static 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
2062int 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 */
2093struct {
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 */
2120int 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 */
2148struct {
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 */
2417static 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 */
2460static 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 */
2497static 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 */
2516static 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 */
2556static 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 */
2579static 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 */
2593static 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 */
2607static 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 */
2623static 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 */
2642static 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 */
2658static 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 */
2695static __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 */
2718static __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 */
2730static __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
2735static 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 */
2976static 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 */
2991static 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
3013static 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 */
3036struct {
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
3082static 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 */
3168static 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 */
3182static 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 */
3208static 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 */
3243static 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 */
3271static 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 */
3300static 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
3314struct {
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 */
3332static 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
3368struct must_may {
3369 isl_map *must;
3370 isl_map *may;
3371};
3372
3373static 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
3386static int common_space(void *first, void *second)
3387{
3388 int depth = *(int *)first;
3389 return 2 * depth;
3390}
3391
3392static 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
3407static 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 */
3422static 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 */
3439static 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 */
3454static 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 */
3471static 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
3485static 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 */
3679static 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
3702struct {
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
3717int 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
3740struct {
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
3759static 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 */
3785struct {
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 */
3801static 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 */
3833static 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
3855static 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
3944static 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
3964static 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 */
4015static 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 */
4039static 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 */
4059static 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 */
4130static 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
4148static 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 */
4171static 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
4202struct {
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
4240static 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 */
4268static 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
4285struct {
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
4295static 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 */
4349static 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 */
4373static 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 */
4389static 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
4399int 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
4441static 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
4454int 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 */
4597static __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 */
4627static __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 */
4637static 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
4650int 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 */
4675static 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 */
4713static 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 */
4791static 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 */
4843struct {
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 */
4923static 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 */
4981static 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 */
5015static 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 */
5037static 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 */
5070static 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
5084int 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 */
5397static 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 */
5412static 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
5425int 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
5445int 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 */
5495static 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
5527struct {
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
5537struct {
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 */
5585static 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
5615struct {
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 */
5627struct {
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 */
5649static 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 */
5682static 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 */
5713static 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
5736struct {
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 */
5785static 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
5812struct {
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 */
5826static 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 */
5859struct {
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] }", "[N] -> { B[N