__isl_take isl_aff_list *list);
__isl_give isl_basic_map *isl_basic_map_from_multi_aff(
__isl_take isl_multi_aff *maff)
+ __isl_give isl_map *isl_map_from_multi_aff(
+ __isl_take isl_multi_aff *maff)
__isl_give isl_set *isl_set_from_pw_multi_aff(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_map *isl_map_from_pw_multi_aff(
__isl_give isl_union_map *isl_union_map_coalesce(
__isl_take isl_union_map *umap);
+One of the methods for combining pairs of basic sets or relations
+can result in coefficients that are much larger than those that appear
+in the constraints of the input. By default, the coefficients are
+not allowed to grow larger, but this can be changed by unsetting
+the following option.
+
+ int isl_options_set_coalesce_bounded_wrapping(
+ isl_ctx *ctx, int val);
+ int isl_options_get_coalesce_bounded_wrapping(
+ isl_ctx *ctx);
+
=item * Detecting equalities
__isl_give isl_basic_set *isl_basic_set_detect_equalities(
__isl_take isl_printer *p,
__isl_keep isl_set_list *list);
+=head2 Vectors
+
+Vectors can be created, copied and freed using the following functions.
+
+ #include <isl/vec.h>
+ __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
+ unsigned size);
+ __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
+ void isl_vec_free(__isl_take isl_vec *vec);
+
+Note that the elements of a newly created vector may have arbitrary values.
+The elements can be changed and inspected using the following functions.
+
+ isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
+ int isl_vec_size(__isl_keep isl_vec *vec);
+ int isl_vec_get_element(__isl_keep isl_vec *vec,
+ int pos, isl_int *v);
+ __isl_give isl_vec *isl_vec_set_element(
+ __isl_take isl_vec *vec, int pos, isl_int v);
+ __isl_give isl_vec *isl_vec_set_element_si(
+ __isl_take isl_vec *vec, int pos, int v);
+ __isl_give isl_vec *isl_vec_set(__isl_take isl_vec *vec,
+ isl_int v);
+ __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
+ int v);
+
+C<isl_vec_get_element> will return a negative value if anything went wrong.
+In that case, the value of C<*v> is undefined.
+
=head2 Matrices
Matrices can be created, copied and freed using the following functions.
__isl_take isl_space *space,
__isl_take isl_aff_list *list);
-An empty piecewise multiple quasi affine expression (one with no cells) or
+An empty piecewise multiple quasi affine expression (one with no cells),
+the zero piecewise multiple quasi affine expression (with value zero
+for each output dimension) or
a piecewise multiple quasi affine expression with a single cell can
be created using the following functions.
#include <isl/aff.h>
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
__isl_take isl_space *space);
+ __isl_give isl_multi_aff *isl_multi_aff_zero(
+ __isl_take isl_space *space);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
__isl_take isl_set *set,
__isl_take isl_multi_aff *maff);
It can be modified using
#include <isl/aff.h>
+ __isl_give isl_multi_aff *isl_multi_aff_set_aff(
+ __isl_take isl_multi_aff *multi, int pos,
+ __isl_take isl_aff *aff);
__isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
__isl_take isl_multi_aff *maff,
enum isl_dim_type type, unsigned pos, const char *s);
__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_copy(
__isl_keep isl_union_pw_qpolynomial *upwqp);
- void isl_union_pw_qpolynomial_free(
+ void *isl_union_pw_qpolynomial_free(
__isl_take isl_union_pw_qpolynomial *upwqp);
=head3 Inspecting (Piecewise) Quasipolynomials
__isl_take isl_qpolynomial_fold *fold);
void *isl_pw_qpolynomial_fold_free(
__isl_take isl_pw_qpolynomial_fold *pwf);
- void isl_union_pw_qpolynomial_fold_free(
+ void *isl_union_pw_qpolynomial_fold_free(
__isl_take isl_union_pw_qpolynomial_fold *upwf);
=head3 Printing Piecewise Quasipolynomial Reductions
and potential soure iterations from a particular source domain,
what is the last potential source iteration corresponding to each
sink iteration. It can sometimes be convenient to adjust
-the set of potential source iterations before each such operation.
+the set of potential source iterations before or after each such operation.
The prototypical example is fuzzy array dataflow analysis,
where we need to analyze if, based on data-dependent constraints,
the sink iteration can ever be executed without one or more of
#include <isl/flow.h>
- typedef __isl_give isl_set *(*isl_access_restrict_sources)(
- __isl_take isl_map *source_map,
- void *sink_user, void *source_user);
- __isl_give isl_access_info *
- isl_access_info_set_restrict_sources(
+ typedef __isl_give isl_restriction *(*isl_access_restrict)(
+ __isl_keep isl_map *source_map,
+ __isl_keep isl_set *sink, void *source_user,
+ void *user);
+ __isl_give isl_access_info *isl_access_info_set_restrict(
__isl_take isl_access_info *acc,
- isl_access_restrict_sources fn);
+ isl_access_restrict fn, void *user);
-The function C<isl_access_info_set_restrict_sources> should be called
-before C<isl_access_info_compute_flow> and registers a callback function
+The function C<isl_access_info_set_restrict> should be called
+before calling C<isl_access_info_compute_flow> and registers a callback function
that will be called any time C<isl> is about to compute the last
potential source. The first argument is the (reverse) proto-dependence,
mapping sink iterations to potential source iterations.
-The other two arguments are the tokens corresponding to the sink
-and the source. The callback is expected to return a set
-that restricts the source iterations. The potential source iterations
-will be intersected with this set. If no restrictions are required
-for a given C<source_map>, then the callback should return
+The second argument represents the sink iterations for which
+we want to compute the last source iteration.
+The third argument is the token corresponding to the source
+and the final argument is the token passed to C<isl_access_info_set_restrict>.
+The callback is expected to return a restriction on either the input or
+the output of the operation computing the last potential source.
+If the input needs to be restricted then restrictions are needed
+for both the source and the sink iterations. The sink iterations
+and the potential source iterations will be intersected with these sets.
+If the output needs to be restricted then only a restriction on the source
+iterations is required.
+If any error occurs, the callback should return C<NULL>.
+An C<isl_restriction> object can be created and freed using the following
+functions.
- isl_set_universe(
- isl_space_range(isl_map_get_space(source_map)));
+ #include <isl/flow.h>
-If any error occurs, the callback should return C<NULL>.
+ __isl_give isl_restriction *isl_restriction_input(
+ __isl_take isl_set *source_restr,
+ __isl_take isl_set *sink_restr);
+ __isl_give isl_restriction *isl_restriction_output(
+ __isl_take isl_set *source_restr);
+ __isl_give isl_restriction *isl_restriction_none(
+ __isl_keep isl_map *source_map);
+ __isl_give isl_restriction *isl_restriction_empty(
+ __isl_keep isl_map *source_map);
+ void *isl_restriction_free(
+ __isl_take isl_restriction *restr);
+
+C<isl_restriction_none> and C<isl_restriction_empty> are special
+cases of C<isl_restriction_input>. C<isl_restriction_none>
+is essentially equivalent to
+
+ isl_restriction_input(isl_set_universe(
+ isl_space_range(isl_map_get_space(source_map))),
+ isl_set_universe(
+ isl_space_domain(isl_map_get_space(source_map))));
+
+whereas C<isl_restriction_empty> is essentially equivalent to
+
+ isl_restriction_input(isl_set_empty(
+ isl_space_range(isl_map_get_space(source_map))),
+ isl_set_universe(
+ isl_space_domain(isl_map_get_space(source_map))));
=head2 Scheduling
projects / platform / upstream / isl.git / blobdiff