]>
Commit | Line | Data |
---|---|---|
59f07695 JB |
1 | From b561f860f2fefa84459750d576807d214e4aad97 Mon Sep 17 00:00:00 2001 |
2 | From: Sven Verdoolaege <skimo@kotnet.org> | |
3 | Date: Sun, 12 Jan 2014 14:35:00 +0100 | |
4 | Subject: [PATCH] cloog_domain_cube: reimplement using documented functions | |
5 | ||
6 | The original implementation used the undocumented | |
7 | isl_basic_set_interval function, which will be removed | |
8 | in the next release of isl. | |
9 | ||
10 | Signed-off-by: Sven Verdoolaege <skimo@kotnet.org> | |
11 | Signed-off-by: Cedric Bastoul <cedric.bastoul@unistra.fr> | |
12 | --- | |
13 | source/isl/domain.c | 20 ++++++++++---------- | |
14 | 1 files changed, 10 insertions(+), 10 deletions(-) | |
15 | ||
16 | diff --git a/source/isl/domain.c b/source/isl/domain.c | |
17 | index d11da7b..620584d 100644 | |
18 | --- a/source/isl/domain.c | |
19 | +++ b/source/isl/domain.c | |
20 | @@ -1389,20 +1389,20 @@ CloogDomain *cloog_domain_cube(CloogState *state, | |
21 | int dim, cloog_int_t min, cloog_int_t max) | |
22 | { | |
23 | int i; | |
24 | - struct isl_basic_set *cube; | |
25 | - struct isl_basic_set *interval; | |
26 | - struct isl_basic_set_list *list; | |
27 | + isl_space *space; | |
28 | + isl_set *cube; | |
29 | ||
30 | if (dim == 0) | |
31 | return cloog_domain_universe(state, dim); | |
32 | ||
33 | - interval = isl_basic_set_interval(state->backend->ctx, min, max); | |
34 | - list = isl_basic_set_list_alloc(state->backend->ctx, dim); | |
35 | - for (i = 0; i < dim; ++i) | |
36 | - list = isl_basic_set_list_add(list, isl_basic_set_copy(interval)); | |
37 | - isl_basic_set_free(interval); | |
38 | - cube = isl_basic_set_list_product(list); | |
39 | - return cloog_domain_from_isl_set(isl_set_from_basic_set(cube)); | |
40 | + space = isl_space_set_alloc(state->backend->ctx, 0, dim); | |
41 | + cube = isl_set_universe(space); | |
42 | + for (i = 0; i < dim; ++i) { | |
43 | + cube = isl_set_lower_bound(cube, isl_dim_set, i, min); | |
44 | + cube = isl_set_upper_bound(cube, isl_dim_set, i, max); | |
45 | + } | |
46 | + | |
47 | + return cloog_domain_from_isl_set(cube); | |
48 | } | |
49 | ||
50 | ||
51 | -- | |
52 | 1.7.6.6.GIT | |
53 | ||
54 | From 2d8b7c6b43ee46fee978a57fa6877de49675f357 Mon Sep 17 00:00:00 2001 | |
55 | From: Taj Muhammad Khan <taj.khan@lri.fr> | |
56 | Date: Thu, 5 Dec 2013 07:55:16 +0530 | |
57 | Subject: [PATCH] Use isl_val instead of isl_int | |
58 | ||
59 | isl is moving from the macro-based isl_int to a more generic | |
60 | integer type isl_val, so CLooG does with this patch. | |
61 | Authors are Uday Bondhugula, Taj Muhammad Khan and Cedric Bastoul. | |
62 | --- | |
63 | include/cloog/isl/constraintset.h | 6 + | |
64 | source/isl/constraints.c | 247 +++++++++++++++++++--------- | |
65 | source/isl/domain.c | 329 ++++++++++++++++++++++++------------- | |
66 | 3 files changed, 389 insertions(+), 193 deletions(-) | |
67 | ||
68 | diff --git a/include/cloog/isl/constraintset.h b/include/cloog/isl/constraintset.h | |
69 | index c3c2eed..5d48cdb 100644 | |
70 | --- a/include/cloog/isl/constraintset.h | |
71 | +++ b/include/cloog/isl/constraintset.h | |
72 | @@ -27,6 +27,12 @@ CloogConstraintSet *cloog_constraint_set_from_isl_basic_set(struct isl_basic_set | |
73 | CloogConstraint *cloog_constraint_from_isl_constraint(struct isl_constraint *constraint); | |
74 | isl_constraint *cloog_constraint_to_isl(CloogConstraint *constraint); | |
75 | ||
76 | +__isl_give isl_val *cloog_int_to_isl_val(isl_ctx* ctx, cloog_int_t c); | |
77 | +void isl_val_to_cloog_int(__isl_keep isl_val *val, cloog_int_t *cint); | |
78 | + | |
79 | +__isl_give isl_val *cloog_constraint_coefficient_get_val(CloogConstraint *constraint, | |
80 | + int var); | |
81 | + | |
82 | #if defined(__cplusplus) | |
83 | } | |
84 | #endif | |
85 | diff --git a/source/isl/constraints.c b/source/isl/constraints.c | |
86 | index e860000..73d72df 100644 | |
87 | --- a/source/isl/constraints.c | |
88 | +++ b/source/isl/constraints.c | |
89 | @@ -5,11 +5,51 @@ | |
90 | #include <cloog/isl/backend.h> | |
91 | #include <isl/aff.h> | |
92 | #include <isl/set.h> | |
93 | +#include <isl/val.h> | |
94 | +#include <isl/val_gmp.h> | |
95 | ||
96 | ||
97 | #define ALLOC(type) (type*)malloc(sizeof(type)) | |
98 | #define ALLOCN(type,n) (type*)malloc((n)*sizeof(type)) | |
99 | ||
100 | +__isl_give isl_val *cloog_int_to_isl_val(isl_ctx* ctx, cloog_int_t c) | |
101 | +{ | |
102 | + isl_val *v; | |
103 | +#if defined(CLOOG_INT_INT) | |
104 | + v = isl_val_int_from_si(ctx, c); | |
105 | +#elif defined(CLOOG_INT_LONG) | |
106 | + v = isl_val_int_from_si(ctx, c); | |
107 | +#elif defined(CLOOG_INT_LONG_LONG) | |
108 | + v = isl_val_int_from_si(ctx, c); | |
109 | +#elif defined(CLOOG_INT_GMP) | |
110 | + v = isl_val_int_from_gmp(ctx, c); | |
111 | +#else | |
112 | +#error "No integer type defined" | |
113 | +#endif | |
114 | + return v; | |
115 | +} | |
116 | + | |
117 | +/* | |
118 | + * CLooG'll be dealing in integers so we expect numerator/1 form | |
119 | + * from isl_val. Thus get numerator to assign to cloog_int | |
120 | + */ | |
121 | +void isl_val_to_cloog_int(__isl_keep isl_val *val, cloog_int_t *cint) | |
122 | +{ | |
123 | + assert(isl_val_is_int(val)); | |
124 | +#if defined(CLOOG_INT_INT) | |
125 | + *cint = isl_val_get_num_si(val); | |
126 | +#elif defined(CLOOG_INT_LONG) | |
127 | + *cint = isl_val_get_num_si(val); | |
128 | +#elif defined(CLOOG_INT_LONG_LONG) | |
129 | + *cint = isl_val_get_num_si(val); | |
130 | +#elif defined(CLOOG_INT_GMP) | |
131 | + isl_val_get_num_gmp(val, *cint); | |
132 | +#else | |
133 | +#error "No integer type defined" | |
134 | +#endif | |
135 | +} | |
136 | + | |
137 | + | |
138 | CloogConstraintSet *cloog_constraint_set_from_isl_basic_set(struct isl_basic_set *bset) | |
139 | { | |
140 | return (CloogConstraintSet *)bset; | |
141 | @@ -266,53 +306,65 @@ int cloog_equal_count(CloogEqualities *equal) | |
142 | static int cloog_constraint_equal_type(CloogConstraint *cc, int level) | |
143 | { | |
144 | int i; | |
145 | - isl_int c; | |
146 | + isl_val *c; | |
147 | int type = EQTYPE_NONE; | |
148 | struct isl_constraint *constraint = cloog_constraint_to_isl(cc); | |
149 | ||
150 | - isl_int_init(c); | |
151 | - isl_constraint_get_constant(constraint, &c); | |
152 | - if (!isl_int_is_zero(c)) | |
153 | + c = isl_constraint_get_constant_val(constraint); | |
154 | + if (!isl_val_is_zero(c)) | |
155 | type = EQTYPE_CONSTANT; | |
156 | - isl_constraint_get_coefficient(constraint, isl_dim_set, level - 1, &c); | |
157 | - if (!isl_int_is_one(c) && !isl_int_is_negone(c)) | |
158 | + isl_val_free(c); | |
159 | + c = isl_constraint_get_coefficient_val(constraint, isl_dim_set, level - 1); | |
160 | + if (!isl_val_is_one(c) && !isl_val_is_negone(c)) | |
161 | type = EQTYPE_EXAFFINE; | |
162 | + isl_val_free(c); | |
163 | for (i = 0; i < isl_constraint_dim(constraint, isl_dim_param); ++i) { | |
164 | - isl_constraint_get_coefficient(constraint, isl_dim_param, i, &c); | |
165 | - if (isl_int_is_zero(c)) | |
166 | + c = isl_constraint_get_coefficient_val(constraint, isl_dim_param, i); | |
167 | + if (isl_val_is_zero(c)){ | |
168 | + isl_val_free(c); | |
169 | continue; | |
170 | - if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) || | |
171 | + } | |
172 | + if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) || | |
173 | type != EQTYPE_NONE) { | |
174 | type = EQTYPE_EXAFFINE; | |
175 | + isl_val_free(c); | |
176 | break; | |
177 | } | |
178 | type = EQTYPE_PUREITEM; | |
179 | + isl_val_free(c); | |
180 | } | |
181 | for (i = 0; i < isl_constraint_dim(constraint, isl_dim_set); ++i) { | |
182 | if (i == level - 1) | |
183 | continue; | |
184 | - isl_constraint_get_coefficient(constraint, isl_dim_set, i, &c); | |
185 | - if (isl_int_is_zero(c)) | |
186 | + c = isl_constraint_get_coefficient_val(constraint, isl_dim_set, i); | |
187 | + if (isl_val_is_zero(c)){ | |
188 | + isl_val_free(c); | |
189 | continue; | |
190 | - if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) || | |
191 | + } | |
192 | + if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) || | |
193 | type != EQTYPE_NONE) { | |
194 | type = EQTYPE_EXAFFINE; | |
195 | + isl_val_free(c); | |
196 | break; | |
197 | } | |
198 | type = EQTYPE_PUREITEM; | |
199 | + isl_val_free(c); | |
200 | } | |
201 | for (i = 0; i < isl_constraint_dim(constraint, isl_dim_div); ++i) { | |
202 | - isl_constraint_get_coefficient(constraint, isl_dim_div, i, &c); | |
203 | - if (isl_int_is_zero(c)) | |
204 | + c = isl_constraint_get_coefficient_val(constraint, isl_dim_div, i); | |
205 | + if (isl_val_is_zero(c)){ | |
206 | + isl_val_free(c); | |
207 | continue; | |
208 | - if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) || | |
209 | + } | |
210 | + if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) || | |
211 | type != EQTYPE_NONE) { | |
212 | type = EQTYPE_EXAFFINE; | |
213 | + isl_val_free(c); | |
214 | break; | |
215 | } | |
216 | type = EQTYPE_PUREITEM; | |
217 | + isl_val_free(c); | |
218 | } | |
219 | - isl_int_clear(c); | |
220 | ||
221 | if (type == EQTYPE_NONE) | |
222 | type = EQTYPE_CONSTANT; | |
223 | @@ -447,27 +499,31 @@ static struct clast_expr *div_expr(CloogConstraint *constraint, int pos, | |
224 | { | |
225 | int i, nb_elts; | |
226 | unsigned dim = cloog_constraint_total_dimension(constraint); | |
227 | - cloog_int_t c; | |
228 | + isl_val *c; | |
229 | struct clast_reduction *r; | |
230 | struct clast_expr *e = NULL; | |
231 | isl_aff *div; | |
232 | + cloog_int_t cint; | |
233 | ||
234 | + cloog_int_init(cint); | |
235 | div = isl_constraint_get_div(cloog_constraint_to_isl(constraint), pos); | |
236 | ||
237 | - cloog_int_init(c); | |
238 | for (i = 0, nb_elts = 0; i < dim; ++i) { | |
239 | struct cloog_isl_dim dim; | |
240 | ||
241 | dim = constraint_cloog_dim_to_isl_dim(constraint, i); | |
242 | if (dim.type == isl_dim_set) | |
243 | dim.type = isl_dim_in; | |
244 | - isl_aff_get_coefficient(div, dim.type, dim.pos, &c); | |
245 | - if (!cloog_int_is_zero(c)) | |
246 | + c = isl_aff_get_coefficient_val(div, dim.type, dim.pos); | |
247 | + if (!isl_val_is_zero(c)) | |
248 | ++nb_elts; | |
249 | + | |
250 | + isl_val_free(c); | |
251 | } | |
252 | - isl_aff_get_constant(div, &c); | |
253 | - if (!cloog_int_is_zero(c)) | |
254 | + c = isl_aff_get_constant_val(div); | |
255 | + if (!isl_val_is_zero(c)) | |
256 | ++nb_elts; | |
257 | + isl_val_free(c); | |
258 | ||
259 | r = new_clast_reduction(clast_red_sum, nb_elts); | |
260 | for (i = 0, nb_elts = 0; i < dim; ++i) { | |
261 | @@ -477,22 +533,35 @@ static struct clast_expr *div_expr(CloogConstraint *constraint, int pos, | |
262 | dim = constraint_cloog_dim_to_isl_dim(constraint, i); | |
263 | if (dim.type == isl_dim_set) | |
264 | dim.type = isl_dim_in; | |
265 | - isl_aff_get_coefficient(div, dim.type, dim.pos, &c); | |
266 | - if (cloog_int_is_zero(c)) | |
267 | + c = isl_aff_get_coefficient_val(div, dim.type, dim.pos); | |
268 | + if (isl_val_is_zero(c)){ | |
269 | + isl_val_free(c); | |
270 | continue; | |
271 | + } | |
272 | ||
273 | v = cloog_constraint_variable_expr(constraint, 1 + i, names); | |
274 | ||
275 | - r->elts[nb_elts++] = &new_clast_term(c, v)->expr; | |
276 | + /* We are interested only in the numerator */ | |
277 | + cloog_int_set_si(cint, isl_val_get_num_si(c)); | |
278 | + r->elts[nb_elts++] = &new_clast_term(cint, v)->expr; | |
279 | + | |
280 | + isl_val_free(c); | |
281 | + } | |
282 | + | |
283 | + c = isl_aff_get_constant_val(div); | |
284 | + if (!isl_val_is_zero(c)) { | |
285 | + /* We are interested only in the numerator */ | |
286 | + cloog_int_set_si(cint, isl_val_get_num_si(c)); | |
287 | + r->elts[nb_elts++] = &new_clast_term(cint, NULL)->expr; | |
288 | } | |
289 | - isl_aff_get_constant(div, &c); | |
290 | - if (!cloog_int_is_zero(c)) | |
291 | - r->elts[nb_elts++] = &new_clast_term(c, NULL)->expr; | |
292 | + isl_val_free(c); | |
293 | ||
294 | - isl_aff_get_denominator(div, &c); | |
295 | - e = &new_clast_binary(clast_bin_fdiv, &r->expr, c)->expr; | |
296 | + c = isl_aff_get_denominator_val(div); | |
297 | + isl_val_to_cloog_int(c, &cint); | |
298 | + isl_val_free(c); | |
299 | + e = &new_clast_binary(clast_bin_fdiv, &r->expr, cint)->expr; | |
300 | ||
301 | - cloog_int_clear(c); | |
302 | + cloog_int_clear(cint); | |
303 | ||
304 | isl_aff_free(div); | |
305 | ||
306 | @@ -529,37 +598,34 @@ struct clast_expr *cloog_constraint_variable_expr(CloogConstraint *constraint, | |
307 | */ | |
308 | int cloog_constraint_involves(CloogConstraint *constraint, int v) | |
309 | { | |
310 | - isl_int c; | |
311 | + isl_val *c; | |
312 | int res; | |
313 | ||
314 | - isl_int_init(c); | |
315 | - cloog_constraint_coefficient_get(constraint, v, &c); | |
316 | - res = !isl_int_is_zero(c); | |
317 | - isl_int_clear(c); | |
318 | + c = cloog_constraint_coefficient_get_val(constraint, v); | |
319 | + res = !isl_val_is_zero(c); | |
320 | + isl_val_free(c); | |
321 | return res; | |
322 | } | |
323 | ||
324 | int cloog_constraint_is_lower_bound(CloogConstraint *constraint, int v) | |
325 | { | |
326 | - isl_int c; | |
327 | + isl_val *c; | |
328 | int res; | |
329 | ||
330 | - isl_int_init(c); | |
331 | - cloog_constraint_coefficient_get(constraint, v, &c); | |
332 | - res = isl_int_is_pos(c); | |
333 | - isl_int_clear(c); | |
334 | + c = cloog_constraint_coefficient_get_val(constraint, v); | |
335 | + res = isl_val_is_pos(c); | |
336 | + isl_val_free(c); | |
337 | return res; | |
338 | } | |
339 | ||
340 | int cloog_constraint_is_upper_bound(CloogConstraint *constraint, int v) | |
341 | { | |
342 | - isl_int c; | |
343 | + isl_val *c; | |
344 | int res; | |
345 | ||
346 | - isl_int_init(c); | |
347 | - cloog_constraint_coefficient_get(constraint, v, &c); | |
348 | - res = isl_int_is_neg(c); | |
349 | - isl_int_clear(c); | |
350 | + c = cloog_constraint_coefficient_get_val(constraint, v); | |
351 | + res = isl_val_is_neg(c); | |
352 | + isl_val_free(c); | |
353 | return res; | |
354 | } | |
355 | ||
356 | @@ -585,15 +651,37 @@ void cloog_constraint_coefficient_get(CloogConstraint *constraint, | |
357 | { | |
358 | struct cloog_isl_dim dim; | |
359 | isl_constraint *c; | |
360 | + isl_val *ival; | |
361 | + | |
362 | + if (!constraint) | |
363 | + val = NULL; | |
364 | + | |
365 | + dim = constraint_cloog_dim_to_isl_dim(constraint, var); | |
366 | + c = cloog_constraint_to_isl(constraint); | |
367 | + ival = isl_constraint_get_coefficient_val(c, dim.type, dim.pos); | |
368 | + | |
369 | + isl_val_to_cloog_int(ival, val); | |
370 | + isl_val_free(ival); | |
371 | +} | |
372 | + | |
373 | +isl_val *cloog_constraint_coefficient_get_val(CloogConstraint *constraint, | |
374 | + int var) | |
375 | +{ | |
376 | + struct cloog_isl_dim dim; | |
377 | + isl_constraint *c; | |
378 | + isl_val *val; | |
379 | ||
380 | if (!constraint) | |
381 | - return; | |
382 | + return NULL; | |
383 | ||
384 | dim = constraint_cloog_dim_to_isl_dim(constraint, var); | |
385 | c = cloog_constraint_to_isl(constraint); | |
386 | - isl_constraint_get_coefficient(c, dim.type, dim.pos, val); | |
387 | + val = isl_constraint_get_coefficient_val(c, dim.type, dim.pos); | |
388 | + return val; | |
389 | } | |
390 | ||
391 | + | |
392 | + | |
393 | void cloog_constraint_coefficient_set(CloogConstraint *constraint, | |
394 | int var, cloog_int_t val) | |
395 | { | |
396 | @@ -604,14 +692,26 @@ void cloog_constraint_coefficient_set(CloogConstraint *constraint, | |
397 | ||
398 | dim = constraint_cloog_dim_to_isl_dim(constraint, var); | |
399 | c = cloog_constraint_to_isl(constraint); | |
400 | - isl_constraint_set_coefficient(c, dim.type, dim.pos, val); | |
401 | + isl_constraint_set_coefficient_val(c, dim.type, dim.pos, | |
402 | + cloog_int_to_isl_val(isl_constraint_get_ctx(c), val)); | |
403 | } | |
404 | ||
405 | void cloog_constraint_constant_get(CloogConstraint *constraint, cloog_int_t *val) | |
406 | { | |
407 | - isl_constraint_get_constant(cloog_constraint_to_isl(constraint), val); | |
408 | + isl_val *ival; | |
409 | + ival = isl_constraint_get_constant_val(cloog_constraint_to_isl(constraint)); | |
410 | + isl_val_to_cloog_int(ival, val); | |
411 | + isl_val_free(ival); | |
412 | } | |
413 | ||
414 | + | |
415 | +__isl_give isl_val *cloog_constraint_constant_get_val(CloogConstraint *constraint) | |
416 | +{ | |
417 | + return isl_constraint_get_constant_val(cloog_constraint_to_isl(constraint)); | |
418 | +} | |
419 | + | |
420 | + | |
421 | + | |
422 | /** | |
423 | * Copy the coefficient of constraint c into dst in PolyLib order, | |
424 | * i.e., first the coefficients of the variables, then the coefficients | |
425 | @@ -700,15 +800,11 @@ CloogConstraintSet *cloog_constraint_set_for_reduction(CloogConstraint *upper, | |
426 | ||
427 | static int add_constant_term(CloogConstraint *c, void *user) | |
428 | { | |
429 | - isl_int *bound = (isl_int *)user; | |
430 | - isl_int v; | |
431 | - | |
432 | - isl_int_init(v); | |
433 | - | |
434 | - cloog_constraint_constant_get(c, &v); | |
435 | - isl_int_add(*bound, *bound, v); | |
436 | + isl_val **bound = (isl_val **)user; | |
437 | + isl_val *v; | |
438 | ||
439 | - isl_int_clear(v); | |
440 | + v = cloog_constraint_constant_get_val(c); | |
441 | + *bound = isl_val_add(*bound, v); | |
442 | ||
443 | return 0; | |
444 | } | |
445 | @@ -822,11 +918,14 @@ CloogConstraintSet *cloog_constraint_set_reduce(CloogConstraintSet *constraints, | |
446 | c = isl_constraint_set_coefficient_si(c, isl_dim_set, dim.pos, -1); | |
447 | bset = isl_basic_set_add_constraint(bset, c); | |
448 | ||
449 | - isl_int_set_si(*bound, 0); | |
450 | + cloog_int_set_si(*bound, 0); | |
451 | + isl_val *v = cloog_int_to_isl_val(isl_basic_set_get_ctx(bset), *bound); | |
452 | constraints = cloog_constraint_set_from_isl_basic_set(bset); | |
453 | cloog_constraint_set_foreach_constraint(constraints, | |
454 | - add_constant_term, bound); | |
455 | + add_constant_term, &v); | |
456 | + isl_val_to_cloog_int(v, bound); //return the value to bound | |
457 | ||
458 | + isl_val_free(v); | |
459 | isl_basic_set_free(orig); | |
460 | return cloog_constraint_set_from_isl_basic_set(bset); | |
461 | } | |
462 | @@ -896,31 +995,27 @@ static isl_aff *extract_stride_offset(__isl_keep isl_constraint *c, | |
463 | isl_space *dim = isl_constraint_get_space(c); | |
464 | isl_local_space *ls = isl_local_space_from_space(dim); | |
465 | isl_aff *offset = isl_aff_zero_on_domain(ls); | |
466 | - isl_int u; | |
467 | + isl_val *u; | |
468 | unsigned nparam, nvar; | |
469 | ||
470 | - isl_int_init(u); | |
471 | - | |
472 | nparam = isl_constraint_dim(c, isl_dim_param); | |
473 | nvar = isl_constraint_dim(c, isl_dim_set); | |
474 | ||
475 | for (i = 0; i < nparam; ++i) { | |
476 | - isl_constraint_get_coefficient(c, isl_dim_param, i, &u); | |
477 | - isl_int_mul(u, u, stride->factor); | |
478 | - offset = isl_aff_set_coefficient(offset, isl_dim_param, i, u); | |
479 | + u = isl_constraint_get_coefficient_val(c, isl_dim_param, i); | |
480 | + u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor)); | |
481 | + offset = isl_aff_set_coefficient_val(offset, isl_dim_param, i, u); | |
482 | } | |
483 | for (i = 0; i < nvar; ++i) { | |
484 | if (i == level - 1) | |
485 | continue; | |
486 | - isl_constraint_get_coefficient(c, isl_dim_set, i, &u); | |
487 | - isl_int_mul(u, u, stride->factor); | |
488 | - offset = isl_aff_set_coefficient(offset, isl_dim_in, i, u); | |
489 | + u = isl_constraint_get_coefficient_val(c, isl_dim_set, i); | |
490 | + u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor)); | |
491 | + offset = isl_aff_set_coefficient_val(offset, isl_dim_in, i, u); | |
492 | } | |
493 | - isl_constraint_get_constant(c, &u); | |
494 | - isl_int_mul(u, u, stride->factor); | |
495 | - offset = isl_aff_set_constant(offset, u); | |
496 | - | |
497 | - isl_int_clear(u); | |
498 | + u = isl_constraint_get_constant_val(c); | |
499 | + u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor)); | |
500 | + offset = isl_aff_set_constant_val(offset, u); | |
501 | ||
502 | return offset; | |
503 | } | |
504 | @@ -953,9 +1048,9 @@ CloogConstraint *cloog_constraint_stride_lower_bound(CloogConstraint *c, | |
505 | offset = extract_stride_offset(stride_c, level, stride); | |
506 | ||
507 | lower = isl_aff_sub(lower, isl_aff_copy(offset)); | |
508 | - lower = isl_aff_scale_down(lower, stride->stride); | |
509 | + lower = isl_aff_scale_down_val(lower, cloog_int_to_isl_val(isl_constraint_get_ctx(stride_c), stride->stride)); | |
510 | lower = isl_aff_ceil(lower); | |
511 | - lower = isl_aff_scale(lower, stride->stride); | |
512 | + lower = isl_aff_scale_val(lower, cloog_int_to_isl_val(isl_constraint_get_ctx(stride_c), stride->stride)); | |
513 | lower = isl_aff_add(lower, offset); | |
514 | lower = isl_aff_neg(lower); | |
515 | lower = isl_aff_add_coefficient_si(lower, isl_dim_in, level - 1, 1); | |
516 | diff --git a/source/isl/domain.c b/source/isl/domain.c | |
517 | index 620584d..dc81a96 100644 | |
518 | --- a/source/isl/domain.c | |
519 | +++ b/source/isl/domain.c | |
520 | @@ -7,7 +7,11 @@ | |
521 | #include <isl/list.h> | |
522 | #include <isl/constraint.h> | |
523 | #include <isl/ilp.h> | |
524 | +#include <isl/lp.h> | |
525 | #include <isl/aff.h> | |
526 | +#include <isl/map.h> | |
527 | +#include <isl/val.h> | |
528 | +#include <isl/val_gmp.h> | |
529 | ||
530 | #ifdef OSL_SUPPORT | |
531 | #include <osl/macros.h> | |
532 | @@ -510,15 +514,18 @@ static struct isl_constraint *isl_constraint_read_from_matrix( | |
533 | else | |
534 | constraint = isl_inequality_alloc(ls); | |
535 | ||
536 | - for (j = 0; j < nvariables; ++j) | |
537 | - isl_constraint_set_coefficient(constraint, isl_dim_out, j, | |
538 | - row[1 + j]); | |
539 | + for (j = 0; j < nvariables; ++j) { | |
540 | + isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + j]); | |
541 | + isl_constraint_set_coefficient_val(constraint, isl_dim_out, j, val); | |
542 | + } | |
543 | ||
544 | - for (j = 0; j < nparam; ++j) | |
545 | - isl_constraint_set_coefficient(constraint, isl_dim_param, j, | |
546 | - row[1 + nvariables + j]); | |
547 | + for (j = 0; j < nparam; ++j) { | |
548 | + isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + nvariables + j]); | |
549 | + isl_constraint_set_coefficient_val(constraint, isl_dim_param, j, val); | |
550 | + } | |
551 | ||
552 | - isl_constraint_set_constant(constraint, row[1 + nvariables + nparam]); | |
553 | + isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + nvariables + nparam]); | |
554 | + isl_constraint_set_constant_val(constraint, val); | |
555 | ||
556 | return constraint; | |
557 | } | |
558 | @@ -631,7 +638,6 @@ CloogDomain *cloog_domain_from_osl_relation(CloogState *state, | |
559 | return domain; | |
560 | } | |
561 | ||
562 | - | |
563 | /** | |
564 | * Converts an openscop scattering relation to a CLooG scattering. | |
565 | * \param[in,out] state CLooG state. | |
566 | @@ -779,10 +785,22 @@ int cloog_domain_is_otl(CloogDomain *domain, int level) | |
567 | void cloog_domain_stride(CloogDomain *domain, int strided_level, | |
568 | cloog_int_t *stride, cloog_int_t *offset) | |
569 | { | |
570 | + int ret = -1; | |
571 | isl_set *set = isl_set_from_cloog_domain(domain); | |
572 | - isl_set_dim_residue_class(set, strided_level - 1, stride, offset); | |
573 | - if (!isl_int_is_zero(*offset)) | |
574 | - isl_int_sub(*offset, *stride, *offset); | |
575 | + isl_val *stride_val = NULL; | |
576 | + isl_val *offset_val = NULL; | |
577 | + ret = isl_set_dim_residue_class_val(set, strided_level - 1, &stride_val, &offset_val); | |
578 | + if (ret != 0) | |
579 | + cloog_die("failure to compute stride.\n"); | |
580 | + isl_val_to_cloog_int(stride_val, stride); | |
581 | + isl_val_to_cloog_int(offset_val, offset); | |
582 | + | |
583 | + if (!cloog_int_is_zero(*offset)) | |
584 | + cloog_int_sub(*offset, *stride, *offset); | |
585 | + | |
586 | + isl_val_free(stride_val); | |
587 | + isl_val_free(offset_val); | |
588 | + | |
589 | return; | |
590 | } | |
591 | ||
592 | @@ -796,7 +814,7 @@ static int constraint_can_stride(__isl_take isl_constraint *c, void *user) | |
593 | { | |
594 | struct cloog_can_stride *ccs = (struct cloog_can_stride *)user; | |
595 | int i; | |
596 | - isl_int v; | |
597 | + isl_val *v; | |
598 | unsigned n_div; | |
599 | ||
600 | if (isl_constraint_is_equality(c)) { | |
601 | @@ -804,21 +822,22 @@ static int constraint_can_stride(__isl_take isl_constraint *c, void *user) | |
602 | return 0; | |
603 | } | |
604 | ||
605 | - isl_int_init(v); | |
606 | - isl_constraint_get_coefficient(c, isl_dim_set, ccs->level - 1, &v); | |
607 | - if (isl_int_is_pos(v)) { | |
608 | + v = isl_constraint_get_coefficient_val(c, isl_dim_set, ccs->level - 1); | |
609 | + if (isl_val_is_pos(v)) { | |
610 | n_div = isl_constraint_dim(c, isl_dim_div); | |
611 | + | |
612 | for (i = 0; i < n_div; ++i) { | |
613 | - isl_constraint_get_coefficient(c, isl_dim_div, i, &v); | |
614 | - if (!isl_int_is_zero(v)) | |
615 | + isl_val_free(v); | |
616 | + v = isl_constraint_get_coefficient_val(c, isl_dim_div, i); | |
617 | + if (!isl_val_is_zero(v)) | |
618 | break; | |
619 | } | |
620 | if (i < n_div) | |
621 | ccs->can_stride = 0; | |
622 | } | |
623 | - isl_int_clear(v); | |
624 | - isl_constraint_free(c); | |
625 | + isl_val_free(v); | |
626 | ||
627 | + isl_constraint_free(c); | |
628 | return 0; | |
629 | } | |
630 | ||
631 | @@ -903,7 +922,7 @@ struct cloog_stride_lower { | |
632 | static int constraint_stride_lower(__isl_take isl_constraint *c, void *user) | |
633 | { | |
634 | struct cloog_stride_lower *csl = (struct cloog_stride_lower *)user; | |
635 | - isl_int v; | |
636 | + isl_val *v; | |
637 | isl_constraint *bound; | |
638 | isl_aff *b; | |
639 | ||
640 | @@ -912,31 +931,31 @@ static int constraint_stride_lower(__isl_take isl_constraint *c, void *user) | |
641 | return 0; | |
642 | } | |
643 | ||
644 | - isl_int_init(v); | |
645 | - isl_constraint_get_coefficient(c, isl_dim_set, csl->level - 1, &v); | |
646 | - if (!isl_int_is_pos(v)) { | |
647 | - isl_int_clear(v); | |
648 | + v = isl_constraint_get_coefficient_val(c, isl_dim_set, csl->level - 1); | |
649 | + if (!isl_val_is_pos(v)) { | |
650 | + isl_val_free(v); | |
651 | isl_constraint_free(c); | |
652 | ||
653 | return 0; | |
654 | } | |
655 | + isl_val_free(v); | |
656 | ||
657 | b = isl_constraint_get_bound(c, isl_dim_set, csl->level - 1); | |
658 | ||
659 | b = isl_aff_neg(b); | |
660 | - b = isl_aff_add_constant(b, csl->stride->offset); | |
661 | - b = isl_aff_scale_down(b, csl->stride->stride); | |
662 | + b = isl_aff_add_constant_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->offset)); | |
663 | + b = isl_aff_scale_down_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->stride)); | |
664 | b = isl_aff_floor(b); | |
665 | - b = isl_aff_scale(b, csl->stride->stride); | |
666 | - isl_int_neg(v, csl->stride->offset); | |
667 | - b = isl_aff_add_constant(b, v); | |
668 | + b = isl_aff_scale_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->stride)); | |
669 | + v = cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->offset); | |
670 | + v = isl_val_neg(v); | |
671 | + b = isl_aff_add_constant_val(b, v); | |
672 | b = isl_aff_add_coefficient_si(b, isl_dim_in, csl->level - 1, 1); | |
673 | ||
674 | bound = isl_inequality_from_aff(b); | |
675 | ||
676 | csl->bounds = isl_basic_set_add_constraint(csl->bounds, bound); | |
677 | ||
678 | - isl_int_clear(v); | |
679 | isl_constraint_free(c); | |
680 | ||
681 | return 0; | |
682 | @@ -960,7 +979,7 @@ static int constraint_stride_lower(__isl_take isl_constraint *c, void *user) | |
683 | static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user) | |
684 | { | |
685 | struct cloog_stride_lower *csl = (struct cloog_stride_lower *)user; | |
686 | - isl_int v; | |
687 | + isl_val *v; | |
688 | isl_constraint *bound; | |
689 | isl_constraint *csl_c; | |
690 | isl_aff *d, *b; | |
691 | @@ -970,10 +989,9 @@ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user) | |
692 | return 0; | |
693 | } | |
694 | ||
695 | - isl_int_init(v); | |
696 | - isl_constraint_get_coefficient(c, isl_dim_set, csl->level - 1, &v); | |
697 | - if (!isl_int_is_pos(v)) { | |
698 | - isl_int_clear(v); | |
699 | + v = isl_constraint_get_coefficient_val(c, isl_dim_set, csl->level - 1); | |
700 | + if (!isl_val_is_pos(v)) { | |
701 | + isl_val_free(v); | |
702 | isl_constraint_free(c); | |
703 | ||
704 | return 0; | |
705 | @@ -984,15 +1002,15 @@ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user) | |
706 | d = isl_constraint_get_aff(csl_c); | |
707 | d = isl_aff_drop_dims(d, isl_dim_div, 0, isl_aff_dim(d, isl_dim_div)); | |
708 | d = isl_aff_set_coefficient_si(d, isl_dim_in, csl->level - 1, 0); | |
709 | - d = isl_aff_scale(d, csl->stride->factor); | |
710 | + d = isl_aff_scale_val(d, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->factor)); | |
711 | ||
712 | b = isl_constraint_get_bound(c, isl_dim_set, csl->level - 1); | |
713 | ||
714 | b = isl_aff_neg(b); | |
715 | b = isl_aff_add(b, isl_aff_copy(d)); | |
716 | - b = isl_aff_scale_down(b, csl->stride->stride); | |
717 | + b = isl_aff_scale_down_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->stride)); | |
718 | b = isl_aff_floor(b); | |
719 | - b = isl_aff_scale(b, csl->stride->stride); | |
720 | + b = isl_aff_scale_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->stride)); | |
721 | b = isl_aff_sub(b, d); | |
722 | b = isl_aff_add_coefficient_si(b, isl_dim_in, csl->level - 1, 1); | |
723 | ||
724 | @@ -1000,7 +1018,7 @@ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user) | |
725 | ||
726 | csl->bounds = isl_basic_set_add_constraint(csl->bounds, bound); | |
727 | ||
728 | - isl_int_clear(v); | |
729 | + isl_val_free(v); | |
730 | isl_constraint_free(c); | |
731 | ||
732 | return 0; | |
733 | @@ -1090,28 +1108,30 @@ struct cloog_bound_split { | |
734 | static int constraint_bound_split(__isl_take isl_constraint *c, void *user) | |
735 | { | |
736 | struct cloog_bound_split *cbs = (struct cloog_bound_split *)user; | |
737 | - isl_int v; | |
738 | + isl_val *v; | |
739 | int i; | |
740 | int handle = 0; | |
741 | ||
742 | - isl_int_init(v); | |
743 | - isl_constraint_get_coefficient(c, isl_dim_set, cbs->level - 1, &v); | |
744 | - if (!cbs->lower && isl_int_is_pos(v)) | |
745 | + v = isl_constraint_get_coefficient_val(c, isl_dim_set, cbs->level - 1); | |
746 | + if (!cbs->lower && isl_val_is_pos(v)) | |
747 | cbs->lower = handle = 1; | |
748 | - else if (!cbs->upper && isl_int_is_neg(v)) | |
749 | + else if (!cbs->upper && isl_val_is_neg(v)) | |
750 | cbs->upper = handle = 1; | |
751 | + | |
752 | if (handle) { | |
753 | for (i = 0; i < isl_set_dim(cbs->set, isl_dim_param); ++i) { | |
754 | - isl_constraint_get_coefficient(c, isl_dim_param, i, &v); | |
755 | - if (isl_int_is_zero(v)) | |
756 | + isl_val_free(v); | |
757 | + v = isl_constraint_get_coefficient_val(c, isl_dim_param, i); | |
758 | + if (isl_val_is_zero(v)) | |
759 | continue; | |
760 | + | |
761 | cbs->set = isl_set_split_dims(cbs->set, | |
762 | isl_dim_param, i, 1); | |
763 | } | |
764 | } | |
765 | - isl_int_clear(v); | |
766 | - isl_constraint_free(c); | |
767 | + isl_val_free(v); | |
768 | ||
769 | + isl_constraint_free(c); | |
770 | return (cbs->lower && cbs->upper) ? -1 : 0; | |
771 | } | |
772 | ||
773 | @@ -1203,7 +1223,7 @@ static int injective_scattering(CloogScatteringList *list) | |
774 | * - scattdims is the total number of scattering dimentions. | |
775 | */ | |
776 | int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2, | |
777 | - CloogScatteringList *scattering, int scattdims) | |
778 | + CloogScatteringList *scattering, int scattdims) | |
779 | { | |
780 | int i; | |
781 | struct isl_space *dim; | |
782 | @@ -1211,8 +1231,8 @@ int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2, | |
783 | struct isl_set *delta; | |
784 | isl_map *map1 = isl_map_from_cloog_scattering(s1); | |
785 | isl_map *map2 = isl_map_from_cloog_scattering(s2); | |
786 | - int fixed, block; | |
787 | - isl_int cst; | |
788 | + int block; | |
789 | + isl_val *cst; | |
790 | unsigned n_scat; | |
791 | ||
792 | n_scat = isl_map_dim(map1, isl_dim_out); | |
793 | @@ -1225,22 +1245,33 @@ int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2, | |
794 | rel = isl_map_apply_domain(rel, isl_map_copy(map1)); | |
795 | rel = isl_map_apply_range(rel, isl_map_copy(map2)); | |
796 | delta = isl_map_deltas(rel); | |
797 | - isl_int_init(cst); | |
798 | + cst = NULL; | |
799 | for (i = 0; i < n_scat; ++i) { | |
800 | - fixed = isl_set_fast_dim_is_fixed(delta, i, &cst); | |
801 | - if (fixed != 1) | |
802 | + cst = isl_set_plain_get_val_if_fixed(delta, isl_dim_set, i); | |
803 | + if (!cst){ | |
804 | + isl_val_free(cst); | |
805 | break; | |
806 | - if (isl_int_is_zero(cst)) | |
807 | + } | |
808 | + if (isl_val_is_zero(cst)){ | |
809 | + isl_val_free(cst); | |
810 | continue; | |
811 | - if (i + 1 < n_scat) | |
812 | + } | |
813 | + if (i + 1 < n_scat){ | |
814 | + isl_val_free(cst); | |
815 | break; | |
816 | - if (!isl_int_is_one(cst)) | |
817 | + } | |
818 | + if (!isl_val_is_one(cst)){ | |
819 | + isl_val_free(cst); | |
820 | break; | |
821 | - if (!injective_scattering(scattering)) | |
822 | + } | |
823 | + if (!injective_scattering(scattering)){ | |
824 | + isl_val_free(cst); | |
825 | break; | |
826 | + } | |
827 | + | |
828 | + isl_val_free(cst); | |
829 | } | |
830 | block = i >= n_scat; | |
831 | - isl_int_clear(cst); | |
832 | isl_set_free(delta); | |
833 | return block; | |
834 | } | |
835 | @@ -1345,10 +1376,25 @@ CloogDomain *cloog_domain_simplify_union(CloogDomain *domain) | |
836 | * If value is not NULL, then it is set to the constant value of dimension. | |
837 | */ | |
838 | int cloog_scattering_lazy_isscalar(CloogScattering *scatt, int dimension, | |
839 | - cloog_int_t *value) | |
840 | + cloog_int_t *value) | |
841 | { | |
842 | isl_map *map = isl_map_from_cloog_scattering(scatt); | |
843 | - return isl_map_fast_is_fixed(map, isl_dim_out, dimension, value); | |
844 | + isl_val *v = isl_map_plain_get_val_if_fixed(map, isl_dim_out, dimension); | |
845 | + if (v != NULL) { | |
846 | + if (!isl_val_is_nan(v)){ | |
847 | + if (value != NULL) | |
848 | + isl_val_to_cloog_int(v, value); | |
849 | + | |
850 | + isl_val_free(v); | |
851 | + return 1; | |
852 | + } | |
853 | + else { | |
854 | + isl_val_free(v); | |
855 | + return 0; | |
856 | + } | |
857 | + } | |
858 | + | |
859 | + return 0; | |
860 | } | |
861 | ||
862 | ||
863 | @@ -1362,7 +1408,22 @@ int cloog_domain_lazy_isconstant(CloogDomain *domain, int dimension, | |
864 | cloog_int_t *value) | |
865 | { | |
866 | isl_set *set = isl_set_from_cloog_domain(domain); | |
867 | - return isl_set_fast_dim_is_fixed(set, dimension, value); | |
868 | + isl_val *cst = isl_set_plain_get_val_if_fixed(set, isl_dim_set, dimension); | |
869 | + if (cst != NULL) { | |
870 | + if (!isl_val_is_nan(cst)){ | |
871 | + if (value != NULL) | |
872 | + isl_val_to_cloog_int(cst, value); | |
873 | + | |
874 | + isl_val_free(cst); | |
875 | + return 1; | |
876 | + } | |
877 | + else { | |
878 | + isl_val_free(cst); | |
879 | + return 0; | |
880 | + } | |
881 | + } | |
882 | + | |
883 | + return 0; | |
884 | } | |
885 | ||
886 | ||
887 | @@ -1391,6 +1452,8 @@ CloogDomain *cloog_domain_cube(CloogState *state, | |
888 | int i; | |
889 | isl_space *space; | |
890 | isl_set *cube; | |
891 | + isl_val *min_v; | |
892 | + isl_val *max_v; | |
893 | ||
894 | if (dim == 0) | |
895 | return cloog_domain_universe(state, dim); | |
896 | @@ -1398,8 +1461,10 @@ CloogDomain *cloog_domain_cube(CloogState *state, | |
897 | space = isl_space_set_alloc(state->backend->ctx, 0, dim); | |
898 | cube = isl_set_universe(space); | |
899 | for (i = 0; i < dim; ++i) { | |
900 | - cube = isl_set_lower_bound(cube, isl_dim_set, i, min); | |
901 | - cube = isl_set_upper_bound(cube, isl_dim_set, i, max); | |
902 | + min_v = cloog_int_to_isl_val(isl_set_get_ctx(cube), min); | |
903 | + max_v = cloog_int_to_isl_val(isl_set_get_ctx(cube), max); | |
904 | + cube = isl_set_lower_bound_val(cube, isl_dim_set, i, min_v); | |
905 | + cube = isl_set_upper_bound_val(cube, isl_dim_set, i, max_v); | |
906 | } | |
907 | ||
908 | return cloog_domain_from_isl_set(cube); | |
909 | @@ -1595,7 +1660,7 @@ static void Euclid(cloog_int_t a, cloog_int_t b, | |
910 | cloog_int_mul(tmp, tmp, d); | |
911 | cloog_int_sub(c, c, tmp); | |
912 | cloog_int_swap(c, d); | |
913 | - cloog_int_swap(e, f); | |
914 | + cloog_int_swap(e, f); | |
915 | } | |
916 | cloog_int_set(*g, c); | |
917 | if (cloog_int_is_zero(a)) | |
918 | @@ -1631,49 +1696,70 @@ static void Euclid(cloog_int_t a, cloog_int_t b, | |
919 | static CloogStride *construct_stride(isl_constraint *c, int level) | |
920 | { | |
921 | int i, n, sign; | |
922 | - isl_int v, m, gcd, stride, factor; | |
923 | + isl_val *v, *m, *gcd, *stride; | |
924 | + isl_val *v_copy, *m_copy, *gcd_copy; | |
925 | + cloog_int_t c_v, c_m, c_gcd, c_stride, c_factor; | |
926 | CloogStride *s; | |
927 | + isl_ctx *ctx = isl_constraint_get_ctx(c);; | |
928 | ||
929 | if (!c) | |
930 | return NULL; | |
931 | ||
932 | - isl_int_init(v); | |
933 | - isl_int_init(m); | |
934 | - isl_int_init(gcd); | |
935 | - isl_int_init(factor); | |
936 | - isl_int_init(stride); | |
937 | + v = isl_constraint_get_coefficient_val(c, isl_dim_set, level - 1); | |
938 | ||
939 | - isl_constraint_get_coefficient(c, isl_dim_set, level - 1, &v); | |
940 | - sign = isl_int_sgn(v); | |
941 | - isl_int_abs(m, v); | |
942 | + sign = isl_val_sgn(v); | |
943 | + m = isl_val_abs(v); /* *takes* v. */ | |
944 | ||
945 | - isl_int_set_si(gcd, 0); | |
946 | + gcd = isl_val_int_from_si(ctx, 0); | |
947 | n = isl_constraint_dim(c, isl_dim_div); | |
948 | for (i = 0; i < n; ++i) { | |
949 | - isl_constraint_get_coefficient(c, isl_dim_div, i, &v); | |
950 | - isl_int_gcd(gcd, gcd, v); | |
951 | + v = isl_constraint_get_coefficient_val(c, isl_dim_div, i); | |
952 | + gcd = isl_val_gcd(gcd, v); | |
953 | } | |
954 | ||
955 | - isl_int_gcd(v, m, gcd); | |
956 | - isl_int_divexact(stride, gcd, v); | |
957 | + m_copy = isl_val_copy(m); | |
958 | + gcd_copy = isl_val_copy(gcd); | |
959 | ||
960 | - if (isl_int_is_zero(stride) || isl_int_is_one(stride)) | |
961 | + v = isl_val_gcd(m, gcd); | |
962 | + | |
963 | + v_copy = isl_val_copy(v); | |
964 | + gcd = isl_val_copy(gcd_copy); | |
965 | + stride = isl_val_div(gcd, v); | |
966 | + | |
967 | + if (isl_val_is_zero(stride) || isl_val_is_one(stride)) | |
968 | s = NULL; | |
969 | else { | |
970 | - Euclid(m, stride, &factor, &v, &gcd); | |
971 | + cloog_int_init(c_m); | |
972 | + cloog_int_init(c_stride); | |
973 | + cloog_int_init(c_v); | |
974 | + cloog_int_init(c_gcd); | |
975 | + cloog_int_init(c_factor); | |
976 | + | |
977 | + isl_val_to_cloog_int(m_copy, &c_m); | |
978 | + isl_val_to_cloog_int(stride, &c_stride); | |
979 | + isl_val_to_cloog_int(v_copy, &c_v); | |
980 | + isl_val_to_cloog_int(gcd_copy, &c_gcd); | |
981 | + | |
982 | + Euclid(c_m, c_stride, &c_factor, &c_v, &c_gcd); | |
983 | if (sign > 0) | |
984 | - isl_int_neg(factor, factor); | |
985 | + cloog_int_neg(c_factor, c_factor); | |
986 | ||
987 | c = isl_constraint_copy(c); | |
988 | - s = cloog_stride_alloc_from_constraint(stride, | |
989 | - cloog_constraint_from_isl_constraint(c), factor); | |
990 | + s = cloog_stride_alloc_from_constraint(c_stride, | |
991 | + cloog_constraint_from_isl_constraint(c), c_factor); | |
992 | + | |
993 | + | |
994 | + cloog_int_clear(c_m); | |
995 | + cloog_int_clear(c_stride); | |
996 | + cloog_int_clear(c_v); | |
997 | + cloog_int_clear(c_gcd); | |
998 | + cloog_int_clear(c_factor); | |
999 | } | |
1000 | ||
1001 | - isl_int_clear(stride); | |
1002 | - isl_int_clear(factor); | |
1003 | - isl_int_clear(gcd); | |
1004 | - isl_int_clear(m); | |
1005 | - isl_int_clear(v); | |
1006 | + isl_val_free(stride); | |
1007 | + isl_val_free(gcd_copy); | |
1008 | + isl_val_free(m_copy); | |
1009 | + isl_val_free(v_copy); | |
1010 | ||
1011 | return s; | |
1012 | } | |
1013 | @@ -1694,7 +1780,7 @@ static int find_stride(__isl_take isl_constraint *c, void *user) | |
1014 | { | |
1015 | struct cloog_isl_find_stride_data *data; | |
1016 | int n; | |
1017 | - isl_int v; | |
1018 | + isl_val *v; | |
1019 | ||
1020 | if (!isl_constraint_is_equality(c)) { | |
1021 | isl_constraint_free(c); | |
1022 | @@ -1714,13 +1800,11 @@ static int find_stride(__isl_take isl_constraint *c, void *user) | |
1023 | return 0; | |
1024 | } | |
1025 | ||
1026 | - isl_int_init(v); | |
1027 | - | |
1028 | - isl_constraint_get_coefficient(c, isl_dim_set, data->level - 1, &v); | |
1029 | - if (!isl_int_is_zero(v)) | |
1030 | + v = isl_constraint_get_coefficient_val(c, isl_dim_set, data->level - 1); | |
1031 | + if (!isl_val_is_zero(v)) | |
1032 | data->stride = construct_stride(c, data->level); | |
1033 | ||
1034 | - isl_int_clear(v); | |
1035 | + isl_val_free(v); | |
1036 | ||
1037 | isl_constraint_free(c); | |
1038 | ||
1039 | @@ -1769,7 +1853,7 @@ struct cloog_can_unroll { | |
1040 | int level; | |
1041 | isl_constraint *c; | |
1042 | isl_set *set; | |
1043 | - isl_int *n; | |
1044 | + isl_val *n; | |
1045 | }; | |
1046 | ||
1047 | ||
1048 | @@ -1782,11 +1866,11 @@ struct cloog_can_unroll { | |
1049 | * with l the given lower bound and i the iterator identified by level. | |
1050 | */ | |
1051 | static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu, | |
1052 | - __isl_keep isl_constraint *c, isl_int *v) | |
1053 | + __isl_keep isl_constraint *c, isl_val **v) | |
1054 | { | |
1055 | unsigned n_div; | |
1056 | isl_aff *aff; | |
1057 | - enum isl_lp_result res; | |
1058 | + enum isl_lp_result; | |
1059 | ||
1060 | n_div = isl_constraint_dim(c, isl_dim_div); | |
1061 | if (isl_constraint_involves_dims(c, isl_dim_div, 0, n_div)) | |
1062 | @@ -1796,15 +1880,19 @@ static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu, | |
1063 | aff = isl_aff_ceil(aff); | |
1064 | aff = isl_aff_neg(aff); | |
1065 | aff = isl_aff_add_coefficient_si(aff, isl_dim_in, ccu->level - 1, 1); | |
1066 | - res = isl_set_max(ccu->set, aff, v); | |
1067 | + *v = isl_set_max_val(ccu->set, aff); | |
1068 | isl_aff_free(aff); | |
1069 | ||
1070 | - if (res == isl_lp_unbounded) | |
1071 | - return 0; | |
1072 | + if (!*v || isl_val_is_nan(*v)) | |
1073 | + cloog_die("Fail to decide about unrolling (cannot find max)"); | |
1074 | ||
1075 | - assert(res == isl_lp_ok); | |
1076 | + if (isl_val_is_infty(*v) || isl_val_is_neginfty(*v)){ | |
1077 | + isl_val_free(*v); | |
1078 | + *v = NULL; | |
1079 | + return 0; | |
1080 | + } | |
1081 | ||
1082 | - cloog_int_add_ui(*v, *v, 1); | |
1083 | + *v = isl_val_add_ui(*v, 1); | |
1084 | ||
1085 | return 1; | |
1086 | } | |
1087 | @@ -1818,21 +1906,21 @@ static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu, | |
1088 | static int constraint_can_unroll(__isl_take isl_constraint *c, void *user) | |
1089 | { | |
1090 | struct cloog_can_unroll *ccu = (struct cloog_can_unroll *)user; | |
1091 | - isl_int v; | |
1092 | - isl_int count; | |
1093 | - | |
1094 | - isl_int_init(v); | |
1095 | - isl_int_init(count); | |
1096 | - isl_constraint_get_coefficient(c, isl_dim_set, ccu->level - 1, &v); | |
1097 | - if (isl_int_is_pos(v) && | |
1098 | - is_valid_unrolling_lower_bound(ccu, c, &count) && | |
1099 | - (!ccu->c || isl_int_lt(count, *ccu->n))) { | |
1100 | + isl_val *v; | |
1101 | + isl_val *count = NULL; | |
1102 | + | |
1103 | + v = isl_constraint_get_coefficient_val(c, isl_dim_set, ccu->level - 1); | |
1104 | + if (isl_val_is_pos(v) && | |
1105 | + is_valid_unrolling_lower_bound(ccu, c, &count) && | |
1106 | + (!ccu->c || (isl_val_lt(count, ccu->n))) ) { | |
1107 | isl_constraint_free(ccu->c); | |
1108 | ccu->c = isl_constraint_copy(c); | |
1109 | - isl_int_set(*ccu->n, count); | |
1110 | + if (ccu->n) | |
1111 | + isl_val_free(ccu->n); | |
1112 | + ccu->n = isl_val_copy(count); | |
1113 | } | |
1114 | - isl_int_clear(count); | |
1115 | - isl_int_clear(v); | |
1116 | + isl_val_free(count); | |
1117 | + isl_val_free(v); | |
1118 | isl_constraint_free(c); | |
1119 | ||
1120 | return 0; | |
1121 | @@ -1872,7 +1960,8 @@ int cloog_domain_can_unroll(CloogDomain *domain, int level, cloog_int_t *n, | |
1122 | CloogConstraint **lb) | |
1123 | { | |
1124 | isl_set *set = isl_set_from_cloog_domain(domain); | |
1125 | - struct cloog_can_unroll ccu = { 1, level, NULL, set, n }; | |
1126 | + isl_val *v = cloog_int_to_isl_val(isl_set_get_ctx(set), *n); | |
1127 | + struct cloog_can_unroll ccu = { 1, level, NULL, set, v }; | |
1128 | int r; | |
1129 | ||
1130 | *lb = NULL; | |
1131 | @@ -1887,6 +1976,11 @@ int cloog_domain_can_unroll(CloogDomain *domain, int level, cloog_int_t *n, | |
1132 | ||
1133 | *lb = cloog_constraint_from_isl_constraint(ccu.c); | |
1134 | ||
1135 | + isl_val_to_cloog_int(ccu.n, n); | |
1136 | + /* Note: we have to free ccu.n and not v because v has been | |
1137 | + * freed and replaced in ccu during isl_set_foreach_basic_set | |
1138 | + */ | |
1139 | + isl_val_free(ccu.n); | |
1140 | return ccu.can_unroll; | |
1141 | } | |
1142 | ||
1143 | @@ -1904,6 +1998,7 @@ CloogDomain *cloog_domain_fixed_offset(CloogDomain *domain, | |
1144 | { | |
1145 | isl_aff *aff; | |
1146 | isl_set *set = isl_set_from_cloog_domain(domain); | |
1147 | + isl_ctx *ctx = isl_set_get_ctx(set); | |
1148 | isl_constraint *c; | |
1149 | isl_constraint *eq; | |
1150 | ||
1151 | @@ -1911,7 +2006,7 @@ CloogDomain *cloog_domain_fixed_offset(CloogDomain *domain, | |
1152 | aff = isl_constraint_get_bound(c, isl_dim_set, level - 1); | |
1153 | aff = isl_aff_ceil(aff); | |
1154 | aff = isl_aff_add_coefficient_si(aff, isl_dim_in, level - 1, -1); | |
1155 | - aff = isl_aff_add_constant(aff, offset); | |
1156 | + aff = isl_aff_add_constant_val(aff, cloog_int_to_isl_val(ctx, offset)); | |
1157 | eq = isl_equality_from_aff(aff); | |
1158 | set = isl_set_add_constraint(set, eq); | |
1159 | ||
1160 | -- | |
1161 | 1.7.6.6.GIT | |
1162 |