isl_basic_set_sample: break early if sample found in basic_set_range

[platform/upstream/isl.git] / isl_map.c

diff --git a/isl_map.c b/isl_map.c
index c38d0bb..f7efcb7 100644 (file)
--- a/isl_map.c
+++ b/isl_map.c
@@ -220,6 +220,20 @@ int isl_basic_map_compatible_range(struct isl_basic_map *bmap,
               bmap->dim->nparam == bset->dim->nparam;
 }
 
+struct isl_dim *isl_basic_set_get_dim(struct isl_basic_set *bset)
+{
+       if (!bset)
+               return NULL;
+       return isl_dim_copy(bset->dim);
+}
+
+struct isl_dim *isl_set_get_dim(struct isl_set *set)
+{
+       if (!set)
+               return NULL;
+       return isl_dim_copy(set->dim);
+}
+
 static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx,
                struct isl_basic_map *bmap, unsigned extra,
                unsigned n_eq, unsigned n_ineq)
@@ -374,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;
 }
 
@@ -441,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);
 }
@@ -503,6 +517,11 @@ int isl_basic_map_free_equality(struct isl_basic_map *bmap, unsigned n)
        return 0;
 }
 
+int isl_basic_set_free_equality(struct isl_basic_set *bset, unsigned n)
+{
+       return isl_basic_map_free_equality((struct isl_basic_map *)bset, n);
+}
+
 int isl_basic_map_drop_equality(struct isl_basic_map *bmap, unsigned pos)
 {
        isl_int *t;
@@ -617,6 +636,11 @@ int isl_basic_map_alloc_div(struct isl_basic_map *bmap)
        return bmap->n_div++;
 }
 
+int isl_basic_set_alloc_div(struct isl_basic_set *bset)
+{
+       return isl_basic_map_alloc_div((struct isl_basic_map *)bset);
+}
+
 int isl_basic_map_free_div(struct isl_basic_map *bmap, unsigned n)
 {
        if (!bmap)
@@ -1594,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;
@@ -1602,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;
@@ -1643,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),
@@ -1657,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;
        }
 
@@ -1665,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;
@@ -1806,7 +1830,7 @@ error:
        return NULL;
 }
 
-struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
+static struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
 {
        int i, j;
 
@@ -2629,6 +2653,16 @@ struct isl_set *isl_set_empty_like(struct isl_set *model)
        return isl_set_empty(isl_dim_copy(model->dim));
 }
 
+struct isl_map *isl_map_universe(struct isl_dim *dim)
+{
+       struct isl_map *map;
+       if (!dim)
+               return NULL;
+       map = isl_map_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
+       map = isl_map_add(map, isl_basic_map_universe(dim));
+       return map;
+}
+
 struct isl_set *isl_set_universe(struct isl_dim *dim)
 {
        struct isl_set *set;
@@ -2910,6 +2944,11 @@ error:
        return NULL;
 }
 
+/* If bmap contains any unknown divs, then compute explicit
+ * expressions for them.  However, this computation may be
+ * quite expensive, so first try to remove divs that aren't
+ * strictly needed.
+ */
 struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap)
 {
        int i;
@@ -2920,11 +2959,22 @@ struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap)
        off = isl_dim_total(bmap->dim);
        for (i = 0; i < bmap->n_div; ++i) {
                if (isl_int_is_zero(bmap->div[i][0]))
-                       return isl_pip_basic_map_compute_divs(bmap);
+                       break;
                isl_assert(bmap->ctx, isl_int_is_zero(bmap->div[i][1+1+off+i]),
                                goto error);
        }
-       return isl_map_from_basic_map(bmap);
+       if (i == bmap->n_div)
+               return isl_map_from_basic_map(bmap);
+       bmap = isl_basic_map_drop_redundant_divs(bmap);
+       if (!bmap)
+               goto error;
+       for (i = 0; i < bmap->n_div; ++i)
+               if (isl_int_is_zero(bmap->div[i][0]))
+                       break;
+       if (i == bmap->n_div)
+               return isl_map_from_basic_map(bmap);
+       struct isl_map *map = isl_pip_basic_map_compute_divs(bmap);
+       return map;
 error:
        isl_basic_map_free(bmap);
        return NULL;
@@ -3437,6 +3487,13 @@ int isl_basic_map_is_universe(struct isl_basic_map *bmap)
        return bmap->n_eq == 0 && bmap->n_ineq == 0;
 }
 
+int isl_basic_set_is_universe(struct isl_basic_set *bset)
+{
+       if (!bset)
+               return -1;
+       return bset->n_eq == 0 && bset->n_ineq == 0;
+}
+
 int isl_basic_map_is_empty(struct isl_basic_map *bmap)
 {
        struct isl_basic_set *bset = NULL;
@@ -3466,6 +3523,8 @@ int isl_basic_map_is_empty(struct isl_basic_map *bmap)
                if (contains)
                        return 0;
        }
+       isl_vec_free(bmap->sample);
+       bmap->sample = NULL;
        bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
        if (!bset)
                return -1;
@@ -3473,13 +3532,28 @@ int isl_basic_map_is_empty(struct isl_basic_map *bmap)
        if (!sample)
                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);
 
        return empty;
 }
 
+int isl_basic_map_fast_is_empty(struct isl_basic_map *bmap)
+{
+       if (!bmap)
+               return -1;
+       return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY);
+}
+
+int isl_basic_set_fast_is_empty(struct isl_basic_set *bset)
+{
+       if (!bset)
+               return -1;
+       return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY);
+}
+
 int isl_basic_set_is_empty(struct isl_basic_set *bset)
 {
        return isl_basic_map_is_empty((struct isl_basic_map *)bset);
@@ -3526,7 +3600,7 @@ static struct isl_basic_map *order_divs(struct isl_basic_map *bmap)
                                                            bmap->n_div-i);
                if (pos == -1)
                        continue;
-               swap_div(bmap, i, pos);
+               swap_div(bmap, i, i + pos);
                --i;
        }
        return bmap;
@@ -3620,6 +3694,11 @@ struct isl_map *isl_map_align_divs(struct isl_map *map)
        return map;
 }
 
+struct isl_set *isl_set_align_divs(struct isl_set *set)
+{
+       return (struct isl_set *)isl_map_align_divs((struct isl_map *)set);
+}
+
 static struct isl_map *add_cut_constraint(struct isl_map *dst,
                struct isl_basic_map *src, isl_int *c,
                unsigned len, int oppose)
@@ -3942,7 +4021,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);
@@ -4490,6 +4569,14 @@ error:
        return NULL;
 }
 
+/* Given two set A and B, construct its Cartesian product A x B.
+ */
+struct isl_set *isl_set_product(struct isl_set *set1, struct isl_set *set2)
+{
+       return (struct isl_set *)isl_map_product((struct isl_map *)set1,
+                                                (struct isl_map *)set2);
+}
+
 uint32_t isl_basic_set_get_hash(struct isl_basic_set *bset)
 {
        int i;