From e2a2317bec55cd2bda6822199e1a76088236152e Mon Sep 17 00:00:00 2001 From: Sven Verdoolaege Date: Fri, 1 Jul 2011 17:20:52 +0200 Subject: [PATCH] reimplement isl_constraint in terms of isl_aff This completes the removal of the ability of using isl_constraint as an iterator for the constraints in a set or relation. Signed-off-by: Sven Verdoolaege --- doc/user.pod | 13 +- include/isl/constraint.h | 15 ++- isl_constraint.c | 308 ++++++++++++++++++++++------------------------- isl_constraint_private.h | 6 +- 4 files changed, 168 insertions(+), 174 deletions(-) diff --git a/doc/user.pod b/doc/user.pod index b4c7381..2ece40a 100644 --- a/doc/user.pod +++ b/doc/user.pod @@ -1023,11 +1023,16 @@ using the following functions. __isl_take isl_dim *dim); __isl_give isl_constraint *isl_inequality_alloc( __isl_take isl_dim *dim); - void isl_constraint_set_constant( - __isl_keep isl_constraint *constraint, isl_int v); - void isl_constraint_set_coefficient( - __isl_keep isl_constraint *constraint, + __isl_give isl_constraint *isl_constraint_set_constant( + __isl_take isl_constraint *constraint, isl_int v); + __isl_give isl_constraint *isl_constraint_set_constant_si( + __isl_take isl_constraint *constraint, int v); + __isl_give isl_constraint *isl_constraint_set_coefficient( + __isl_take isl_constraint *constraint, enum isl_dim_type type, int pos, isl_int v); + __isl_give isl_constraint *isl_constraint_set_coefficient_si( + __isl_take isl_constraint *constraint, + enum isl_dim_type type, int pos, int v); __isl_give isl_basic_map *isl_basic_map_add_constraint( __isl_take isl_basic_map *bmap, __isl_take isl_constraint *constraint); diff --git a/include/isl/constraint.h b/include/isl/constraint.h index 3be537a..cc562ba 100644 --- a/include/isl/constraint.h +++ b/include/isl/constraint.h @@ -29,7 +29,7 @@ __isl_give isl_constraint *isl_inequality_alloc(__isl_take isl_dim *dim); struct isl_constraint *isl_constraint_cow(struct isl_constraint *c); struct isl_constraint *isl_constraint_copy(struct isl_constraint *c); -void isl_constraint_free(struct isl_constraint *c); +void *isl_constraint_free(struct isl_constraint *c); int isl_basic_map_foreach_constraint(__isl_keep isl_basic_map *bmap, int (*fn)(__isl_take isl_constraint *c, void *user), void *user); @@ -78,12 +78,15 @@ void isl_constraint_get_constant(__isl_keep isl_constraint *constraint, isl_int *v); void isl_constraint_get_coefficient(__isl_keep isl_constraint *constraint, enum isl_dim_type type, int pos, isl_int *v); -void isl_constraint_set_constant(__isl_keep isl_constraint *constraint, isl_int v); -void isl_constraint_set_constant_si(__isl_keep isl_constraint *constraint, - int v); -void isl_constraint_set_coefficient(__isl_keep isl_constraint *constraint, +__isl_give isl_constraint *isl_constraint_set_constant( + __isl_take isl_constraint *constraint, isl_int v); +__isl_give isl_constraint *isl_constraint_set_constant_si( + __isl_take isl_constraint *constraint, int v); +__isl_give isl_constraint *isl_constraint_set_coefficient( + __isl_take isl_constraint *constraint, enum isl_dim_type type, int pos, isl_int v); -void isl_constraint_set_coefficient_si(__isl_keep isl_constraint *constraint, +__isl_give isl_constraint *isl_constraint_set_coefficient_si( + __isl_take isl_constraint *constraint, enum isl_dim_type type, int pos, int v); __isl_give isl_div *isl_constraint_div(__isl_keep isl_constraint *constraint, diff --git a/isl_constraint.c b/isl_constraint.c index a820ef1..c3c3526 100644 --- a/isl_constraint.c +++ b/isl_constraint.c @@ -16,27 +16,21 @@ #include #include #include +#include isl_ctx *isl_constraint_get_ctx(__isl_keep isl_constraint *c) { - return c ? c->ctx : NULL; + return c ? isl_aff_get_ctx(c->aff) : NULL; } static unsigned n(struct isl_constraint *c, enum isl_dim_type type) { - return isl_basic_map_dim(c->bmap, type); + return isl_aff_dim(c->aff, type); } static unsigned offset(struct isl_constraint *c, enum isl_dim_type type) { - struct isl_dim *dim = c->bmap->dim; - switch (type) { - case isl_dim_param: return 1; - case isl_dim_in: return 1 + dim->nparam; - case isl_dim_out: return 1 + dim->nparam + dim->n_in; - case isl_dim_div: return 1 + dim->nparam + dim->n_in + dim->n_out; - default: return 0; - } + return isl_local_space_offset(c->aff->ls, type); } static unsigned basic_map_offset(__isl_keep isl_basic_map *bmap, @@ -59,24 +53,49 @@ static unsigned basic_set_offset(struct isl_basic_set *bset, } } +__isl_give isl_constraint *isl_constraint_alloc(int eq, __isl_take isl_aff *aff) +{ + isl_constraint *constraint; + + if (!aff) + return NULL; + + constraint = isl_alloc_type(isl_aff_get_ctx(aff), isl_constraint); + if (!constraint) + goto error; + + constraint->ref = 1; + constraint->eq = eq; + constraint->aff = aff; + + return constraint; +error: + isl_aff_free(aff); + return NULL; +} + struct isl_constraint *isl_basic_map_constraint(struct isl_basic_map *bmap, isl_int **line) { - struct isl_constraint *constraint; + int eq; + isl_aff *aff; + isl_local_space *ls; + isl_constraint *constraint; if (!bmap || !line) goto error; - - constraint = isl_alloc_type(bmap->ctx, struct isl_constraint); - if (!constraint) - goto error; - constraint->ctx = bmap->ctx; - isl_ctx_ref(constraint->ctx); - constraint->ref = 1; - constraint->bmap = bmap; - constraint->line = line; + eq = line >= bmap->eq; + + ls = isl_basic_map_get_local_space(bmap); + aff = isl_aff_alloc(ls); + if (!aff) + goto error; + isl_int_set_si(aff->v->el[0], 1); + isl_seq_cpy(aff->v->el + 1, line[0], aff->v->size - 1); + constraint = isl_constraint_alloc(eq, aff); + isl_basic_map_free(bmap); return constraint; error: isl_basic_map_free(bmap); @@ -123,19 +142,10 @@ struct isl_constraint *isl_inequality_alloc(struct isl_dim *dim) struct isl_constraint *isl_constraint_dup(struct isl_constraint *c) { - struct isl_basic_map *bmap; - int i; - int eq; - if (!c) return NULL; - eq = c->line < c->bmap->eq + c->bmap->n_eq; - i = eq ? c->line - c->bmap->eq : c->line - c->bmap->ineq; - bmap = isl_basic_map_copy(c->bmap); - if (!bmap) - return NULL; - return isl_basic_map_constraint(bmap, eq ? bmap->eq + i : bmap->ineq + i); + return isl_constraint_alloc(c->eq, isl_aff_copy(c->aff)); } struct isl_constraint *isl_constraint_cow(struct isl_constraint *c) @@ -158,17 +168,18 @@ struct isl_constraint *isl_constraint_copy(struct isl_constraint *constraint) return constraint; } -void isl_constraint_free(struct isl_constraint *c) +void *isl_constraint_free(struct isl_constraint *c) { if (!c) - return; + return NULL; if (--c->ref > 0) - return; + return NULL; - isl_basic_map_free(c->bmap); - isl_ctx_deref(c->ctx); + isl_aff_free(c->aff); free(c); + + return NULL; } int isl_basic_map_foreach_constraint(__isl_keep isl_basic_map *bmap, @@ -215,18 +226,25 @@ int isl_constraint_is_equal(struct isl_constraint *constraint1, { if (!constraint1 || !constraint2) return 0; - return constraint1->bmap == constraint2->bmap && - constraint1->line == constraint2->line; + return constraint1->eq == constraint2->eq && + isl_aff_plain_is_equal(constraint1->aff, constraint2->aff); } struct isl_basic_map *isl_basic_map_add_constraint( struct isl_basic_map *bmap, struct isl_constraint *constraint) { + isl_ctx *ctx; + isl_dim *dim; + int equal_dim; + if (!bmap || !constraint) goto error; - isl_assert(constraint->ctx, - isl_dim_equal(bmap->dim, constraint->bmap->dim), goto error); + ctx = isl_constraint_get_ctx(constraint); + dim = isl_constraint_get_dim(constraint); + equal_dim = isl_dim_equal(bmap->dim, dim); + isl_dim_free(dim); + isl_assert(ctx, equal_dim, goto error); bmap = isl_basic_map_intersect(bmap, isl_basic_map_from_constraint(constraint)); @@ -265,7 +283,7 @@ __isl_give isl_set *isl_set_add_constraint(__isl_take isl_set *set, __isl_give isl_dim *isl_constraint_get_dim( __isl_keep isl_constraint *constraint) { - return constraint ? isl_basic_map_get_dim(constraint->bmap) : NULL; + return constraint ? isl_aff_get_dim(constraint->aff) : NULL; } int isl_constraint_dim(struct isl_constraint *constraint, @@ -282,30 +300,21 @@ int isl_constraint_involves_dims(__isl_keep isl_constraint *constraint, if (!constraint) return -1; - if (first + n > isl_basic_set_dim(constraint->bmap, type)) - isl_die(constraint->ctx, isl_error_invalid, - "index out of bounds", return -1); - - first += isl_basic_map_offset(constraint->bmap, type); - - if (isl_seq_first_non_zero(constraint->line[0] + first, n) >= 0) - return 1; - - return 0; + return isl_aff_involves_dims(constraint->aff, type, first, n); } const char *isl_constraint_get_dim_name(__isl_keep isl_constraint *constraint, enum isl_dim_type type, unsigned pos) { return constraint ? - isl_basic_map_get_dim_name(constraint->bmap, type, pos) : NULL; + isl_aff_get_dim_name(constraint->aff, type, pos) : NULL; } void isl_constraint_get_constant(struct isl_constraint *constraint, isl_int *v) { if (!constraint) return; - isl_int_set(*v, constraint->line[0][0]); + isl_aff_get_constant(constraint->aff, v); } void isl_constraint_get_coefficient(struct isl_constraint *constraint, @@ -314,8 +323,7 @@ void isl_constraint_get_coefficient(struct isl_constraint *constraint, if (!constraint) return; - isl_assert(constraint->ctx, pos < n(constraint, type), return); - isl_int_set(*v, constraint->line[0][offset(constraint, type) + pos]); + isl_aff_get_coefficient(constraint->aff, type, pos, v); } struct isl_div *isl_constraint_div(struct isl_constraint *constraint, int pos) @@ -323,70 +331,59 @@ struct isl_div *isl_constraint_div(struct isl_constraint *constraint, int pos) if (!constraint) return NULL; - isl_assert(constraint->ctx, pos < n(constraint, isl_dim_div), - return NULL); - isl_assert(constraint->ctx, - !isl_int_is_zero(constraint->bmap->div[pos][0]), return NULL); - return isl_basic_map_div(isl_basic_map_copy(constraint->bmap), pos); + return isl_aff_get_div(constraint->aff, pos); } -void isl_constraint_set_constant(struct isl_constraint *constraint, isl_int v) +__isl_give isl_constraint *isl_constraint_set_constant( + __isl_take isl_constraint *constraint, isl_int v) { + constraint = isl_constraint_cow(constraint); if (!constraint) - return; - isl_int_set(constraint->line[0][0], v); + return NULL; + constraint->aff = isl_aff_set_constant(constraint->aff, v); + if (!constraint->aff) + return isl_constraint_free(constraint); + return constraint; } -void isl_constraint_set_constant_si(__isl_keep isl_constraint *constraint, - int v) +__isl_give isl_constraint *isl_constraint_set_constant_si( + __isl_take isl_constraint *constraint, int v) { + constraint = isl_constraint_cow(constraint); if (!constraint) - return; - isl_int_set_si(constraint->line[0][0], v); + return NULL; + constraint->aff = isl_aff_set_constant_si(constraint->aff, v); + if (!constraint->aff) + return isl_constraint_free(constraint); + return constraint; } -void isl_constraint_set_coefficient(struct isl_constraint *constraint, +__isl_give isl_constraint *isl_constraint_set_coefficient( + __isl_take isl_constraint *constraint, enum isl_dim_type type, int pos, isl_int v) { + constraint = isl_constraint_cow(constraint); if (!constraint) - return; - - isl_assert(constraint->ctx, pos < n(constraint, type), return); - isl_int_set(constraint->line[0][offset(constraint, type) + pos], v); + return NULL; + constraint->aff = isl_aff_set_coefficient(constraint->aff, + type, pos, v); + if (!constraint->aff) + return isl_constraint_free(constraint); + return constraint; } -void isl_constraint_set_coefficient_si(__isl_keep isl_constraint *constraint, +__isl_give isl_constraint *isl_constraint_set_coefficient_si( + __isl_take isl_constraint *constraint, enum isl_dim_type type, int pos, int v) { + constraint = isl_constraint_cow(constraint); if (!constraint) - return; - - isl_assert(constraint->ctx, pos < n(constraint, type), return); - isl_int_set_si(constraint->line[0][offset(constraint, type) + pos], v); -} - - -/* Check whether the two basic maps have identical divs in the same order. - */ -static int equal_divs(__isl_keep isl_basic_map *bmap1, - __isl_keep isl_basic_map *bmap2) -{ - int i; - unsigned total; - - if (!isl_basic_map_divs_known(bmap1)) - return 0; - if (!isl_basic_map_divs_known(bmap2)) - return 0; - if (bmap1->n_div != bmap2->n_div) - return 0; - - total = isl_basic_map_total_dim(bmap1); - for (i = 0; i < bmap1->n_div; ++i) - if (!isl_seq_eq(bmap1->div[i], bmap2->div[i], 2 + total)) - return 0; - - return 1; + return NULL; + constraint->aff = isl_aff_set_coefficient_si(constraint->aff, + type, pos, v); + if (!constraint->aff) + return isl_constraint_free(constraint); + return constraint; } /* Drop any constraint from "bset" that is identical to "constraint". @@ -406,15 +403,20 @@ __isl_give isl_basic_set *isl_basic_set_drop_constraint( unsigned n; isl_int **row; unsigned total; + isl_local_space *ls1, *ls2; + int equal; if (!bset || !constraint) goto error; - if (!isl_dim_equal(bset->dim, constraint->bmap->dim)) - isl_die(bset->ctx, isl_error_invalid, - "spaces don't match", goto error); - - if (bset != constraint->bmap && !equal_divs(bset, constraint->bmap)) { + ls1 = isl_basic_set_get_local_space(bset); + ls2 = isl_aff_get_local_space(constraint->aff); + equal = isl_local_space_is_equal(ls1, ls2); + isl_local_space_free(ls1); + isl_local_space_free(ls2); + if (equal < 0) + goto error; + if (!equal) { isl_constraint_free(constraint); return bset; } @@ -427,9 +429,9 @@ __isl_give isl_basic_set *isl_basic_set_drop_constraint( row = bset->ineq; } - total = isl_basic_map_total_dim(constraint->bmap); + total = isl_aff_dim(constraint->aff, isl_dim_all); for (i = 0; i < n; ++i) - if (isl_seq_eq(row[i], constraint->line[0], 1 + total)) + if (isl_seq_eq(row[i], constraint->aff->v->el + 1, 1 + total)) isl_seq_clr(row[i], 1 + total); isl_constraint_free(constraint); @@ -442,44 +444,43 @@ error: struct isl_constraint *isl_constraint_negate(struct isl_constraint *constraint) { - unsigned total; + isl_ctx *ctx; + constraint = isl_constraint_cow(constraint); if (!constraint) return NULL; - isl_assert(constraint->ctx, !isl_constraint_is_equality(constraint), - goto error); - isl_assert(constraint->ctx, constraint->bmap->ref == 1, goto error); - total = isl_basic_map_total_dim(constraint->bmap); - isl_seq_neg(constraint->line[0], constraint->line[0], 1 + total); - isl_int_sub_ui(constraint->line[0][0], constraint->line[0][0], 1); - ISL_F_CLR(constraint->bmap, ISL_BASIC_MAP_NORMALIZED); + ctx = isl_constraint_get_ctx(constraint); + if (isl_constraint_is_equality(constraint)) + isl_die(ctx, isl_error_invalid, "cannot negate equality", + return isl_constraint_free(constraint)); + constraint->aff = isl_aff_neg(constraint->aff); + constraint->aff = isl_aff_add_constant_si(constraint->aff, -1); + if (!constraint->aff) + return isl_constraint_free(constraint); return constraint; -error: - isl_constraint_free(constraint); - return NULL; } int isl_constraint_is_equality(struct isl_constraint *constraint) { if (!constraint) return -1; - return constraint->line >= constraint->bmap->eq; + return constraint->eq; } int isl_constraint_is_div_constraint(__isl_keep isl_constraint *constraint) { int i; + int n_div; if (!constraint) return -1; if (isl_constraint_is_equality(constraint)) return 0; - for (i = 0; i < constraint->bmap->n_div; ++i) { - if (isl_int_is_zero(constraint->bmap->div[i][0])) - continue; - if (isl_basic_map_is_div_constraint(constraint->bmap, - constraint->line[0], i)) + n_div = isl_aff_dim(constraint->aff, isl_dim_div); + for (i = 0; i < n_div; ++i) { + if (isl_local_space_is_div_constraint(constraint->aff->ls, + constraint->aff->v->el + 1, i)) return 1; } @@ -495,6 +496,7 @@ __isl_give isl_basic_map *isl_basic_map_from_constraint( __isl_take isl_constraint *constraint) { int k; + isl_local_space *ls; struct isl_basic_map *bmap; isl_int *c; unsigned total; @@ -502,15 +504,8 @@ __isl_give isl_basic_map *isl_basic_map_from_constraint( if (!constraint) return NULL; - if (constraint->bmap->n_eq == 1 && constraint->bmap->n_ineq == 0) { - bmap = isl_basic_map_copy(constraint->bmap); - isl_constraint_free(constraint); - return bmap; - } - - bmap = isl_basic_map_universe_like(constraint->bmap); - bmap = isl_basic_map_align_divs(bmap, constraint->bmap); - bmap = isl_basic_map_cow(bmap); + ls = isl_aff_get_local_space(constraint->aff); + bmap = isl_basic_map_from_local_space(ls); bmap = isl_basic_map_extend_constraints(bmap, 1, 1); if (isl_constraint_is_equality(constraint)) { k = isl_basic_map_alloc_equality(bmap); @@ -525,7 +520,7 @@ __isl_give isl_basic_map *isl_basic_map_from_constraint( c = bmap->ineq[k]; } total = isl_basic_map_total_dim(bmap); - isl_seq_cpy(c, constraint->line[0], 1 + total); + isl_seq_cpy(c, constraint->aff->v->el + 1, 1 + total); isl_constraint_free(constraint); if (bmap) ISL_F_SET(bmap, ISL_BASIC_SET_FINAL); @@ -542,11 +537,11 @@ struct isl_basic_set *isl_basic_set_from_constraint( if (!constraint) return NULL; - isl_assert(constraint->ctx,n(constraint, isl_dim_in) == 0, goto error); + if (isl_constraint_dim(constraint, isl_dim_in) != 0) + isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid, + "not a set constraint", + return isl_constraint_free(constraint)); return (isl_basic_set *)isl_basic_map_from_constraint(constraint); -error: - isl_constraint_free(constraint); - return NULL; } int isl_basic_map_has_defining_equality( @@ -985,36 +980,38 @@ __isl_give isl_aff *isl_constraint_get_bound( __isl_keep isl_constraint *constraint, enum isl_dim_type type, int pos) { isl_aff *aff; + isl_ctx *ctx; isl_local_space *ls; if (!constraint) return NULL; - if (pos >= isl_basic_set_dim(constraint->bmap, type)) - isl_die(constraint->ctx, isl_error_invalid, + ctx = isl_constraint_get_ctx(constraint); + if (pos >= isl_constraint_dim(constraint, type)) + isl_die(ctx, isl_error_invalid, "index out of bounds", return NULL); - if (!isl_basic_map_may_be_set(constraint->bmap)) - isl_die(constraint->ctx, isl_error_invalid, + if (isl_constraint_dim(constraint, isl_dim_in) != 0) + isl_die(ctx, isl_error_invalid, "not a set constraint", return NULL); pos += offset(constraint, type); - if (isl_int_is_zero(constraint->line[0][pos])) - isl_die(constraint->ctx, isl_error_invalid, + if (isl_int_is_zero(constraint->aff->v->el[1 + pos])) + isl_die(ctx, isl_error_invalid, "constraint does not define a bound on given dimension", return NULL); - ls = isl_basic_set_get_local_space(constraint->bmap); + ls = isl_aff_get_local_space(constraint->aff); aff = isl_aff_alloc(ls); if (!aff) return NULL; - if (isl_int_is_neg(constraint->line[0][pos])) - isl_seq_cpy(aff->v->el + 1, constraint->line[0], + if (isl_int_is_neg(constraint->aff->v->el[1 + pos])) + isl_seq_cpy(aff->v->el + 1, constraint->aff->v->el + 1, aff->v->size - 1); else - isl_seq_neg(aff->v->el + 1, constraint->line[0], + isl_seq_neg(aff->v->el + 1, constraint->aff->v->el + 1, aff->v->size - 1); isl_int_set_si(aff->v->el[1 + pos], 0); - isl_int_abs(aff->v->el[0], constraint->line[0][pos]); + isl_int_abs(aff->v->el[0], constraint->aff->v->el[1 + pos]); return aff; } @@ -1032,21 +1029,10 @@ __isl_give isl_aff *isl_constraint_get_bound( __isl_give isl_aff *isl_constraint_get_aff( __isl_keep isl_constraint *constraint) { - isl_aff *aff; - isl_local_space *ls; - if (!constraint) return NULL; - ls = isl_basic_set_get_local_space(constraint->bmap); - aff = isl_aff_alloc(ls); - if (!aff) - return NULL; - - isl_seq_cpy(aff->v->el + 1, constraint->line[0], aff->v->size - 1); - isl_int_set_si(aff->v->el[0], 1); - - return aff; + return isl_aff_copy(constraint->aff); } /* Construct an equality constraint equating the given affine expression diff --git a/isl_constraint_private.h b/isl_constraint_private.h index 8fab9d4..529a945 100644 --- a/isl_constraint_private.h +++ b/isl_constraint_private.h @@ -1,14 +1,14 @@ #ifndef ISL_CONSTRAINT_PRIVATE_H #define ISL_CONSTRAINT_PRIVATE_H +#include #include struct isl_constraint { int ref; - struct isl_ctx *ctx; - struct isl_basic_map *bmap; - isl_int **line; + int eq; + isl_aff *aff; }; struct isl_constraint *isl_basic_set_constraint(struct isl_basic_set *bset, -- 2.7.4