scheduling: optionally split parallel rows in non-tilable bands

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

diff --git a/isl_bound.c b/isl_bound.c
index 7660d04..3828f8d 100644 (file)
--- a/isl_bound.c
+++ b/isl_bound.c
@@ -8,6 +8,8 @@
  * 91893 Orsay, France 
  */
 
+#include <isl_ctx_private.h>
+#include <isl_map_private.h>
 #include <isl_bound.h>
 #include <isl_bernstein.h>
 #include <isl_range.h>
@@ -45,7 +47,7 @@ error:
        return -1;
 }
 
-static int guarded_poly_bound(__isl_take isl_basic_set *bset,
+static int unwrapped_guarded_poly_bound(__isl_take isl_basic_set *bset,
        __isl_take isl_qpolynomial *poly, void *user)
 {
        struct isl_bound *bound = (struct isl_bound *)user;
@@ -79,8 +81,9 @@ static int guarded_poly_bound(__isl_take isl_basic_set *bset,
        top_pwf = bound->pwf;
        top_pwf_tight = bound->pwf_tight;
 
-       bound->pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim));
-       bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim);
+       bound->pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim),
+                                                 bound->type);
+       bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, bound->type);
 
        r = compressed_guarded_poly_bound(bset, poly, user);
 
@@ -92,8 +95,8 @@ static int guarded_poly_bound(__isl_take isl_basic_set *bset,
                                                        isl_morph_copy(morph));
        bound->pwf_tight = isl_pw_qpolynomial_fold_morph(bound->pwf_tight, morph);
 
-       bound->pwf = isl_pw_qpolynomial_fold_add(top_pwf, bound->pwf);
-       bound->pwf_tight = isl_pw_qpolynomial_fold_add(top_pwf_tight,
+       bound->pwf = isl_pw_qpolynomial_fold_fold(top_pwf, bound->pwf);
+       bound->pwf_tight = isl_pw_qpolynomial_fold_fold(top_pwf_tight,
                                                        bound->pwf_tight);
 
        return r;
@@ -103,6 +106,52 @@ error:
        return -1;
 }
 
+static int guarded_poly_bound(__isl_take isl_basic_set *bset,
+       __isl_take isl_qpolynomial *poly, void *user)
+{
+       struct isl_bound *bound = (struct isl_bound *)user;
+       isl_dim *dim;
+       isl_pw_qpolynomial_fold *top_pwf;
+       isl_pw_qpolynomial_fold *top_pwf_tight;
+       int nparam;
+       int n_in;
+       int r;
+
+       if (!bound->wrapping)
+               return unwrapped_guarded_poly_bound(bset, poly, user);
+
+       nparam = isl_dim_size(bound->dim, isl_dim_param);
+       n_in = isl_dim_size(bound->dim, isl_dim_set);
+
+       bset = isl_basic_set_move_dims(bset, isl_dim_param, nparam,
+                                       isl_dim_set, 0, n_in);
+       poly = isl_qpolynomial_move_dims(poly, isl_dim_param, nparam,
+                                       isl_dim_set, 0, n_in);
+
+       dim = isl_basic_set_get_dim(bset);
+       dim = isl_dim_drop(dim, isl_dim_set, 0, isl_dim_size(dim, isl_dim_set));
+
+       top_pwf = bound->pwf;
+       top_pwf_tight = bound->pwf_tight;
+
+       bound->pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim),
+                                                 bound->type);
+       bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, bound->type);
+
+       r = unwrapped_guarded_poly_bound(bset, poly, user);
+
+       bound->pwf = isl_pw_qpolynomial_fold_reset_dim(bound->pwf,
+                                                   isl_dim_copy(bound->dim));
+       bound->pwf_tight = isl_pw_qpolynomial_fold_reset_dim(bound->pwf_tight,
+                                                   isl_dim_copy(bound->dim));
+
+       bound->pwf = isl_pw_qpolynomial_fold_fold(top_pwf, bound->pwf);
+       bound->pwf_tight = isl_pw_qpolynomial_fold_fold(top_pwf_tight,
+                                                       bound->pwf_tight);
+
+       return r;
+}
+
 static int guarded_qp(__isl_take isl_qpolynomial *qp, void *user)
 {
        struct isl_bound *bound = (struct isl_bound *)user;
@@ -155,7 +204,6 @@ error:
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_bound(
        __isl_take isl_pw_qpolynomial_fold *pwf, int *tight)
 {
-       isl_dim *dim;
        unsigned nvar;
        struct isl_bound bound;
        int covers;
@@ -163,28 +211,35 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_bound(
        if (!pwf)
                return NULL;
 
-       dim = isl_pw_qpolynomial_fold_get_dim(pwf);
-       nvar = isl_dim_size(dim, isl_dim_set);
+       bound.dim = isl_pw_qpolynomial_fold_get_dim(pwf);
+       nvar = isl_dim_size(bound.dim, isl_dim_set);
 
-       if (isl_pw_qpolynomial_fold_is_zero(pwf)) {
-               isl_pw_qpolynomial_fold_free(pwf);
-               dim = isl_dim_drop(dim, isl_dim_set, 0, nvar);
+       bound.wrapping = isl_dim_is_wrapping(bound.dim);
+       if (bound.wrapping) {
+               bound.dim = isl_dim_unwrap(bound.dim);
+               nvar = isl_dim_size(bound.dim, isl_dim_out);
+               bound.dim = isl_dim_domain(bound.dim);
+       } else
+               bound.dim = isl_dim_drop(bound.dim, isl_dim_set, 0, nvar);
+
+       if (nvar == 0) {
                if (tight)
                        *tight = 1;
-               return isl_pw_qpolynomial_fold_zero(dim);
+               return isl_pw_qpolynomial_fold_reset_dim(pwf, bound.dim);
        }
 
-       if (nvar == 0) {
-               isl_dim_free(dim);
+       if (isl_pw_qpolynomial_fold_is_zero(pwf)) {
+               enum isl_fold type = pwf->type;
+               isl_pw_qpolynomial_fold_free(pwf);
                if (tight)
                        *tight = 1;
-               return pwf;
+               return isl_pw_qpolynomial_fold_zero(bound.dim, type);
        }
 
-       dim = isl_dim_drop(dim, isl_dim_set, 0, nvar);
-
-       bound.pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim));
-       bound.pwf_tight = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim));
+       bound.pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(bound.dim),
+                                                       pwf->type);
+       bound.pwf_tight = isl_pw_qpolynomial_fold_zero(isl_dim_copy(bound.dim),
+                                                       pwf->type);
        bound.check_tight = !!tight;
 
        if (isl_pw_qpolynomial_fold_foreach_lifted_piece(pwf,
@@ -198,7 +253,7 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_bound(
        if (tight)
                *tight = covers;
 
-       isl_dim_free(dim);
+       isl_dim_free(bound.dim);
        isl_pw_qpolynomial_fold_free(pwf);
 
        if (covers) {
@@ -206,14 +261,14 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_bound(
                return bound.pwf_tight;
        }
 
-       bound.pwf = isl_pw_qpolynomial_fold_add(bound.pwf, bound.pwf_tight);
+       bound.pwf = isl_pw_qpolynomial_fold_fold(bound.pwf, bound.pwf_tight);
 
        return bound.pwf;
 error:
        isl_pw_qpolynomial_fold_free(bound.pwf_tight);
        isl_pw_qpolynomial_fold_free(bound.pwf);
        isl_pw_qpolynomial_fold_free(pwf);
-       isl_dim_free(dim);
+       isl_dim_free(bound.dim);
        return NULL;
 }
 
@@ -225,3 +280,52 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_bound(
        pwf = isl_pw_qpolynomial_fold_from_pw_qpolynomial(type, pwqp);
        return isl_pw_qpolynomial_fold_bound(pwf, tight);
 }
+
+struct isl_union_bound_data {
+       enum isl_fold type;
+       int tight;
+       isl_union_pw_qpolynomial_fold *res;
+};
+
+static int bound_pw(__isl_take isl_pw_qpolynomial *pwqp, void *user)
+{
+       struct isl_union_bound_data *data = user;
+       isl_pw_qpolynomial_fold *pwf;
+
+       pwf = isl_pw_qpolynomial_bound(pwqp, data->type,
+                                       data->tight ? &data->tight : NULL);
+       data->res = isl_union_pw_qpolynomial_fold_fold_pw_qpolynomial_fold(
+                                                               data->res, pwf);
+
+       return 0;
+}
+
+__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
+       __isl_take isl_union_pw_qpolynomial *upwqp,
+       enum isl_fold type, int *tight)
+{
+       isl_dim *dim;
+       struct isl_union_bound_data data = { type, 1, NULL };
+
+       if (!upwqp)
+               return NULL;
+
+       if (!tight)
+               data.tight = 0;
+
+       dim = isl_union_pw_qpolynomial_get_dim(upwqp);
+       data.res = isl_union_pw_qpolynomial_fold_zero(dim, type);
+       if (isl_union_pw_qpolynomial_foreach_pw_qpolynomial(upwqp,
+                                                   &bound_pw, &data) < 0)
+               goto error;
+
+       isl_union_pw_qpolynomial_free(upwqp);
+       if (tight)
+               *tight = data.tight;
+
+       return data.res;
+error:
+       isl_union_pw_qpolynomial_free(upwqp);
+       isl_union_pw_qpolynomial_fold_free(data.res);
+       return NULL;
+}