isl_vec: keep track of isl_ctx

diff --git a/isl_affine_hull.c b/isl_affine_hull.c
index f5907e1..679bb3e 100644 (file)
--- a/isl_affine_hull.c
+++ b/isl_affine_hull.c
@@ -221,16 +221,17 @@ error:
        return NULL;
 }
 
-static struct isl_basic_set *isl_basic_set_from_vec(struct isl_ctx *ctx,
-       struct isl_vec *vec)
+static struct isl_basic_set *isl_basic_set_from_vec(struct isl_vec *vec)
 {
        int i;
        int k;
        struct isl_basic_set *bset = NULL;
+       struct isl_ctx *ctx;
        unsigned dim;
 
        if (!vec)
                return NULL;
+       ctx = vec->ctx;
        isl_assert(ctx, vec->size != 0, goto error);
 
        bset = isl_basic_set_alloc(ctx, 0, vec->size - 1, 0, vec->size - 1, 0);
@@ -242,15 +243,15 @@ static struct isl_basic_set *isl_basic_set_from_vec(struct isl_ctx *ctx,
                if (k < 0)
                        goto error;
                isl_seq_clr(bset->eq[k], 1 + dim);
-               isl_int_neg(bset->eq[k][0], vec->block.data[1 + i]);
-               isl_int_set(bset->eq[k][1 + i], vec->block.data[0]);
+               isl_int_neg(bset->eq[k][0], vec->el[1 + i]);
+               isl_int_set(bset->eq[k][1 + i], vec->el[0]);
        }
-       isl_vec_free(ctx, vec);
+       isl_vec_free(vec);
 
        return bset;
 error:
        isl_basic_set_free(bset);
-       isl_vec_free(ctx, vec);
+       isl_vec_free(vec);
        return NULL;
 }
 
@@ -284,8 +285,8 @@ static struct isl_basic_set *outside_point(struct isl_ctx *ctx,
                ctx->one, bset->sample->block.data + 1,
                up ? ctx->one : ctx->negone, eq + 1, dim);
        if (isl_basic_set_contains(bset, sample))
-               return isl_basic_set_from_vec(ctx, sample);
-       isl_vec_free(ctx, sample);
+               return isl_basic_set_from_vec(sample);
+       isl_vec_free(sample);
        sample = NULL;
 
        slice = isl_basic_set_copy(bset);
@@ -306,10 +307,10 @@ static struct isl_basic_set *outside_point(struct isl_ctx *ctx,
        if (!sample)
                goto error;
        if (sample->size == 0) {
-               isl_vec_free(ctx, sample);
+               isl_vec_free(sample);
                point = isl_basic_set_empty_like(bset);
        } else
-               point = isl_basic_set_from_vec(ctx, sample);
+               point = isl_basic_set_from_vec(sample);
 
        return point;
 error:
@@ -389,12 +390,12 @@ static struct isl_basic_set *uset_affine_hull(struct isl_basic_set *bset)
        if (!sample)
                goto error;
        if (sample->size == 0) {
-               isl_vec_free(ctx, sample);
+               isl_vec_free(sample);
                hull = isl_basic_set_empty_like(bset);
                isl_basic_set_free(bset);
                return hull;
        } else
-               hull = isl_basic_set_from_vec(ctx, sample);
+               hull = isl_basic_set_from_vec(sample);
 
        if (hull->n_eq > 0) {
                struct isl_basic_set *cone;

diff --git a/isl_convex_hull.c b/isl_convex_hull.c
index e5ed01c..6b28567 100644 (file)
--- a/isl_convex_hull.c
+++ b/isl_convex_hull.c
@@ -496,7 +496,7 @@ static isl_int *wrap_facet(struct isl_set *set, isl_int *facet, isl_int *ridge)
        }
        isl_int_clear(num);
        isl_int_clear(den);
-       isl_vec_free(set->ctx, obj);
+       isl_vec_free(obj);
        isl_basic_set_free(lp);
        isl_set_free(set);
        isl_assert(set->ctx, res == isl_lp_ok, return NULL);
@@ -1217,13 +1217,13 @@ static struct isl_vec *valid_direction(
                isl_seq_combine(dir->block.data,
                                bset1->ctx->one, dir->block.data,
                                sample->block.data[n++], bset1->ineq[i], 1 + d);
-       isl_vec_free(ctx, sample);
+       isl_vec_free(sample);
        isl_basic_set_free(bset1);
        isl_basic_set_free(bset2);
        isl_seq_normalize(dir->block.data + 1, dir->size - 1);
        return dir;
 error:
-       isl_vec_free(ctx, sample);
+       isl_vec_free(sample);
        isl_basic_set_free(bset1);
        isl_basic_set_free(bset2);
        return NULL;
@@ -1352,11 +1352,11 @@ static struct isl_basic_set *convex_hull_pair_pointed(
        hull = uset_convex_hull(set);
        hull = isl_basic_set_preimage(hull, T);
         
-       isl_vec_free(ctx, dir);
+       isl_vec_free(dir);
 
        return hull;
 error:
-       isl_vec_free(ctx, dir);
+       isl_vec_free(dir);
        isl_basic_set_free(bset1);
        isl_basic_set_free(bset2);
        return NULL;

diff --git a/isl_equalities.c b/isl_equalities.c
index 0632ddd..f13ca6a 100644 (file)
--- a/isl_equalities.c
+++ b/isl_equalities.c
@@ -158,7 +158,7 @@ static struct isl_mat *parameter_compression_multi(struct isl_ctx *ctx,
 
        isl_int_init(D);
 
-       isl_vec_lcm(ctx, d, &D);
+       isl_vec_lcm(d, &D);
 
        size = B->n_col - 1;
        A = isl_mat_alloc(ctx, size, B->n_row * size);
@@ -310,7 +310,7 @@ struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx,
                T = isl_mat_alloc(ctx, B->n_col, 0);
                isl_mat_free(ctx, cst);
                isl_mat_free(ctx, B);
-               isl_vec_free(ctx, d);
+               isl_vec_free(d);
                return T;
        }
        isl_int_init(D);
@@ -321,7 +321,7 @@ struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx,
                        continue;
                if (isl_int_is_zero(D)) {
                        B = isl_mat_drop_rows(ctx, B, i, 1);
-                       d = isl_vec_cow(ctx, d);
+                       d = isl_vec_cow(d);
                        if (!B || !d)
                                goto error2;
                        isl_seq_cpy(d->block.data+i, d->block.data+i+1,
@@ -335,7 +335,7 @@ struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx,
                        goto error2;
                isl_seq_scale_down(B->row[i] + 1, B->row[i] + 1, D, B->n_col-1);
                isl_int_gcd(D, D, d->block.data[i]);
-               d = isl_vec_cow(ctx, d);
+               d = isl_vec_cow(d);
                if (!d)
                        goto error2;
                isl_int_divexact(d->block.data[i], d->block.data[i], D);
@@ -353,14 +353,14 @@ struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx,
        isl_mat_sub_copy(ctx, T->row + 1, cst->row, cst->n_row, 0, 0, 1);
        isl_mat_free(ctx, cst);
        isl_mat_free(ctx, B);
-       isl_vec_free(ctx, d);
+       isl_vec_free(d);
        return T;
 error2:
        isl_int_clear(D);
 error:
        isl_mat_free(ctx, cst);
        isl_mat_free(ctx, B);
-       isl_vec_free(ctx, d);
+       isl_vec_free(d);
        return NULL;
 }
 

diff --git a/isl_map.c b/isl_map.c
index 3f84e07..77c133f 100644 (file)
--- a/isl_map.c
+++ b/isl_map.c
@@ -388,7 +388,7 @@ struct isl_basic_map *isl_basic_map_dup(struct isl_basic_map *bmap)
                return NULL;
        dup_constraints(dup, bmap);
        dup->flags = bmap->flags;
-       dup->sample = isl_vec_copy(bmap->ctx, bmap->sample);
+       dup->sample = isl_vec_copy(bmap->sample);
        return dup;
 }
 
@@ -455,7 +455,7 @@ void isl_basic_map_free(struct isl_basic_map *bmap)
        isl_blk_free(bmap->ctx, bmap->block2);
        free(bmap->ineq);
        isl_blk_free(bmap->ctx, bmap->block);
-       isl_vec_free(bmap->ctx, bmap->sample);
+       isl_vec_free(bmap->sample);
        isl_dim_free(bmap->dim);
        free(bmap);
 }
@@ -1618,7 +1618,7 @@ static int basic_map_contains(struct isl_basic_map *bmap, struct isl_vec *vec)
        isl_int_init(s);
 
        for (i = 0; i < bmap->n_eq; ++i) {
-               isl_seq_inner_product(vec->block.data, bmap->eq[i], total, &s);
+               isl_seq_inner_product(vec->el, bmap->eq[i], total, &s);
                if (!isl_int_is_zero(s)) {
                        isl_int_clear(s);
                        return 0;
@@ -1626,7 +1626,7 @@ static int basic_map_contains(struct isl_basic_map *bmap, struct isl_vec *vec)
        }
 
        for (i = 0; i < bmap->n_ineq; ++i) {
-               isl_seq_inner_product(vec->block.data, bmap->ineq[i], total, &s);
+               isl_seq_inner_product(vec->el, bmap->ineq[i], total, &s);
                if (isl_int_is_neg(s)) {
                        isl_int_clear(s);
                        return 0;
@@ -1667,11 +1667,11 @@ struct isl_basic_map *isl_basic_map_intersect(
        if (bmap1->sample &&
            basic_map_contains(bmap1, bmap1->sample) > 0 &&
            basic_map_contains(bmap2, bmap1->sample) > 0)
-               sample = isl_vec_copy(bmap1->ctx, bmap1->sample);
+               sample = isl_vec_copy(bmap1->sample);
        else if (bmap2->sample &&
            basic_map_contains(bmap1, bmap2->sample) > 0 &&
            basic_map_contains(bmap2, bmap2->sample) > 0)
-               sample = isl_vec_copy(bmap2->ctx, bmap2->sample);
+               sample = isl_vec_copy(bmap2->sample);
 
        bmap1 = isl_basic_map_cow(bmap1);
        bmap1 = isl_basic_map_extend_dim(bmap1, isl_dim_copy(bmap1->dim),
@@ -1681,7 +1681,7 @@ struct isl_basic_map *isl_basic_map_intersect(
        bmap1 = add_constraints(bmap1, bmap2, 0, 0);
 
        if (sample) {
-               isl_vec_free(bmap1->ctx, bmap1->sample);
+               isl_vec_free(bmap1->sample);
                bmap1->sample = sample;
        }
 
@@ -1689,7 +1689,7 @@ struct isl_basic_map *isl_basic_map_intersect(
        return isl_basic_map_finalize(bmap1);
 error:
        if (sample)
-               isl_vec_free(bmap1->ctx, sample);
+               isl_vec_free(sample);
        isl_basic_map_free(bmap1);
        isl_basic_map_free(bmap2);
        return NULL;
@@ -3531,7 +3531,7 @@ int isl_basic_map_is_empty(struct isl_basic_map *bmap)
                return -1;
        empty = sample->size == 0;
        if (bmap->sample)
-               isl_vec_free(bmap->ctx, bmap->sample);
+               isl_vec_free(bmap->sample);
        bmap->sample = sample;
        if (empty)
                ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
@@ -4020,7 +4020,7 @@ int isl_basic_set_compare_at(struct isl_basic_set *bset1,
        isl_int_clear(num);
        isl_int_clear(den);
        isl_basic_map_free(bmap1);
-       isl_vec_free(ctx, obj);
+       isl_vec_free(obj);
        return cmp;
 error:
        isl_basic_map_free(bmap1);

diff --git a/isl_map_simplify.c b/isl_map_simplify.c
index ed74a46..abc7695 100644 (file)
--- a/isl_map_simplify.c
+++ b/isl_map_simplify.c
@@ -1809,15 +1809,15 @@ int isl_basic_map_fast_is_disjoint(struct isl_basic_map *bmap1,
                    isl_seq_first_non_zero(v->block.data + 1, total) == -1)
                        goto disjoint;
        }
-       isl_vec_free(bmap1->ctx, v);
+       isl_vec_free(v);
        free(elim);
        return 0;
 disjoint:
-       isl_vec_free(bmap1->ctx, v);
+       isl_vec_free(v);
        free(elim);
        return 1;
 error:
-       isl_vec_free(bmap1->ctx, v);
+       isl_vec_free(v);
        free(elim);
        return -1;
 }
@@ -2057,8 +2057,8 @@ static struct isl_basic_map *drop_more_redundant_divs(
                                if (!isl_int_is_neg(bmap->ineq[u][1 + dim + i]))
                                        continue;
                                construct_test_ineq(bmap, i, l, u,
-                                                   vec->block.data, g, fl, fu);
-                               res = isl_tab_min(ctx, tab, vec->block.data,
+                                                   vec->el, g, fl, fu);
+                               res = isl_tab_min(ctx, tab, vec->el,
                                                  ctx->one, &g, NULL);
                                if (res == isl_lp_error)
                                        goto error;
@@ -2081,7 +2081,7 @@ static struct isl_basic_map *drop_more_redundant_divs(
        }
 
        isl_tab_free(ctx, tab);
-       isl_vec_free(ctx, vec);
+       isl_vec_free(vec);
 
        isl_int_clear(g);
        isl_int_clear(fl);
@@ -2099,7 +2099,7 @@ error:
        isl_basic_map_free(bmap);
        if (ctx) {
                isl_tab_free(ctx, tab);
-               isl_vec_free(ctx, vec);
+               isl_vec_free(vec);
        }
        isl_int_clear(g);
        isl_int_clear(fl);

diff --git a/isl_mat.c b/isl_mat.c
index 941a48e..d72d929 100644 (file)
--- a/isl_mat.c
+++ b/isl_mat.c
@@ -213,14 +213,14 @@ struct isl_vec *isl_mat_vec_product(struct isl_ctx *ctx,
                goto error;
 
        for (i = 0; i < prod->size; ++i)
-               isl_seq_inner_product(mat->row[i], vec->block.data, vec->size,
+               isl_seq_inner_product(mat->row[i], vec->el, vec->size,
                                        &prod->block.data[i]);
        isl_mat_free(ctx, mat);
-       isl_vec_free(ctx, vec);
+       isl_vec_free(vec);
        return prod;
 error:
        isl_mat_free(ctx, mat);
-       isl_vec_free(ctx, vec);
+       isl_vec_free(vec);
        return NULL;
 }
 

diff --git a/isl_sample.c b/isl_sample.c
index bda8f68..6171c55 100644 (file)
--- a/isl_sample.c
+++ b/isl_sample.c
@@ -48,7 +48,7 @@ static struct isl_vec *interval_sample(struct isl_ctx *ctx,
                }
                isl_int_clear(t);
                if (i < bset->n_ineq) {
-                       isl_vec_free(ctx, sample);
+                       isl_vec_free(sample);
                        sample = isl_vec_alloc(ctx, 0);
                }
        }

diff --git a/isl_sample_piplib.c b/isl_sample_piplib.c
index 478749e..b8c1248 100644 (file)
--- a/isl_sample_piplib.c
+++ b/isl_sample_piplib.c
@@ -188,7 +188,7 @@ struct isl_vec *isl_pip_basic_set_sample(struct isl_basic_set *bset)
        isl_basic_set_free(bset);
        return vec;
 error:
-       isl_vec_free(ctx, vec);
+       isl_vec_free(vec);
        isl_basic_set_free(bset);
        if (sol)
                pip_quast_free(sol);

diff --git a/isl_vec.c b/isl_vec.c
index 533cf04..03723f5 100644 (file)
--- a/isl_vec.c
+++ b/isl_vec.c
@@ -12,8 +12,11 @@ struct isl_vec *isl_vec_alloc(struct isl_ctx *ctx, unsigned size)
        if (isl_blk_is_error(vec->block))
                goto error;
 
+       vec->ctx = ctx;
+       isl_ctx_ref(ctx);
        vec->ref = 1;
        vec->size = size;
+       vec->el = vec->block.data;
 
        return vec;
 error:
@@ -21,7 +24,7 @@ error:
        return NULL;
 }
 
-struct isl_vec *isl_vec_copy(struct isl_ctx *ctx, struct isl_vec *vec)
+struct isl_vec *isl_vec_copy(struct isl_vec *vec)
 {
        if (!vec)
                return NULL;
@@ -30,18 +33,18 @@ struct isl_vec *isl_vec_copy(struct isl_ctx *ctx, struct isl_vec *vec)
        return vec;
 }
 
-struct isl_vec *isl_vec_dup(struct isl_ctx *ctx, struct isl_vec *vec)
+struct isl_vec *isl_vec_dup(struct isl_vec *vec)
 {
        struct isl_vec *vec2;
 
        if (!vec)
                return NULL;
-       vec2 = isl_vec_alloc(ctx, vec->size);
-       isl_seq_cpy(vec2->block.data, vec->block.data, vec->size);
+       vec2 = isl_vec_alloc(vec->ctx, vec->size);
+       isl_seq_cpy(vec2->el, vec->el, vec->size);
        return vec2;
 }
 
-struct isl_vec *isl_vec_cow(struct isl_ctx *ctx, struct isl_vec *vec)
+struct isl_vec *isl_vec_cow(struct isl_vec *vec)
 {
        struct isl_vec *vec2;
        if (!vec)
@@ -50,12 +53,12 @@ struct isl_vec *isl_vec_cow(struct isl_ctx *ctx, struct isl_vec *vec)
        if (vec->ref == 1)
                return vec;
 
-       vec2 = isl_vec_dup(ctx, vec);
-       isl_vec_free(ctx, vec);
+       vec2 = isl_vec_dup(vec);
+       isl_vec_free( vec);
        return vec2;
 }
 
-void isl_vec_free(struct isl_ctx *ctx, struct isl_vec *vec)
+void isl_vec_free(struct isl_vec *vec)
 {
        if (!vec)
                return;
@@ -63,12 +66,12 @@ void isl_vec_free(struct isl_ctx *ctx, struct isl_vec *vec)
        if (--vec->ref > 0)
                return;
 
-       isl_blk_free(ctx, vec->block);
+       isl_ctx_deref(vec->ctx);
+       isl_blk_free(vec->ctx, vec->block);
        free(vec);
 }
 
-void isl_vec_dump(struct isl_ctx *ctx, struct isl_vec *vec,
-                               FILE *out, int indent)
+void isl_vec_dump(struct isl_vec *vec, FILE *out, int indent)
 {
        int i;
 
@@ -81,12 +84,12 @@ void isl_vec_dump(struct isl_ctx *ctx, struct isl_vec *vec,
        for (i = 0; i < vec->size; ++i) {
                if (i)
                    fprintf(out, ",");
-               isl_int_print(out, vec->block.data[i], 0);
+               isl_int_print(out, vec->el[i], 0);
        }
        fprintf(out, "]\n");
 }
 
-void isl_vec_lcm(struct isl_ctx *ctx, struct isl_vec *vec, isl_int *lcm)
+void isl_vec_lcm(struct isl_vec *vec, isl_int *lcm)
 {
        isl_seq_lcm(vec->block.data, vec->size, lcm);
 }

diff --git a/isl_vec.h b/isl_vec.h
index d650ac5..e5c7405 100644 (file)
--- a/isl_vec.h
+++ b/isl_vec.h
@@ -14,20 +14,22 @@ extern "C" {
 struct isl_vec {
        int ref;
 
+       struct isl_ctx *ctx;
+
        unsigned size;
+       isl_int *el;
 
        struct isl_blk block;
 };
 
 struct isl_vec *isl_vec_alloc(struct isl_ctx *ctx, unsigned size);
-struct isl_vec *isl_vec_copy(struct isl_ctx *ctx, struct isl_vec *vec);
-struct isl_vec *isl_vec_cow(struct isl_ctx *ctx, struct isl_vec *vec);
-void isl_vec_free(struct isl_ctx *ctx, struct isl_vec *vec);
+struct isl_vec *isl_vec_copy(struct isl_vec *vec);
+struct isl_vec *isl_vec_cow(struct isl_vec *vec);
+void isl_vec_free(struct isl_vec *vec);
 
-void isl_vec_dump(struct isl_ctx *ctx, struct isl_vec *vec,
-                               FILE *out, int indent);
+void isl_vec_dump(struct isl_vec *vec, FILE *out, int indent);
 
-void isl_vec_lcm(struct isl_ctx *ctx, struct isl_vec *vec, isl_int *lcm);
+void isl_vec_lcm(struct isl_vec *vec, isl_int *lcm);
 
 #if defined(__cplusplus)
 }