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