=item * The function C<isl_pw_aff_max> has been renamed to
C<isl_pw_aff_union_max>.
+Similarly, the function C<isl_pw_aff_add> has been renamed to
+C<isl_pw_aff_union_add>.
=item * The C<isl_dim> type has been renamed to C<isl_space>
along with the associated functions.
=back
+=head2 Error Handling
+
+C<isl> supports different ways to react in case a runtime error is triggered.
+Runtime errors arise, e.g., if a function such as C<isl_map_intersect> is called
+with two maps that have incompatible spaces. There are three possible ways
+to react on error: to warn, to continue or to abort.
+
+The default behavior is to warn. In this mode, C<isl> prints a warning, stores
+the last error in the corresponding C<isl_ctx> and the function in which the
+error was triggered returns C<NULL>. An error does not corrupt internal state,
+such that isl can continue to be used. C<isl> also provides functions to
+read the last error and to reset the memory that stores the last error. The
+last error is only stored for information purposes. Its presence does not
+change the behavior of C<isl>. Hence, resetting an error is not required to
+continue to use isl, but only to observe new errors.
+
+ #include <isl/ctx.h>
+ enum isl_error isl_ctx_last_error(isl_ctx *ctx);
+ void isl_ctx_reset_error(isl_ctx *ctx);
+
+Another option is to continue on error. This is similar to warn on error mode,
+except that C<isl> does not print any warning. This allows a program to
+implement its own error reporting.
+
+The last option is to directly abort the execution of the program from within
+the isl library. This makes it obviously impossible to recover from an error,
+but it allows to directly spot the error location. By aborting on error,
+debuggers break at the location the error occurred and can provide a stack
+trace. Other tools that automatically provide stack traces on abort or that do
+not want to continue execution after an error was triggered may also prefer to
+abort on error.
+
+The on error behavior of isl can be specified by calling
+C<isl_options_set_on_error> or by setting the command line option
+C<--isl-on-error>. Valid arguments for the function call are
+C<ISL_ON_ERROR_WARN>, C<ISL_ON_ERROR_CONTINUE> and C<ISL_ON_ERROR_ABORT>. The
+choices for the command line option are C<warn>, C<continue> and C<abort>.
+It is also possible to query the current error mode.
+
+ #include <isl/options.h>
+ int isl_options_set_on_error(isl_ctx *ctx, int val);
+ int isl_options_get_on_error(isl_ctx *ctx);
+
=head2 Identifiers
Identifiers are used to identify both individual dimensions
unsigned n);
__isl_give isl_space *isl_space_map_from_set(
__isl_take isl_space *space);
+ __isl_give isl_space *isl_space_map_from_domain_and_range(
+ __isl_take isl_space *domain,
+ __isl_take isl_space *range);
__isl_give isl_space *isl_space_zip(__isl_take isl_space *space);
Note that if dimensions are added or removed from a space, then
__isl_give isl_local_space *isl_local_space_domain(
__isl_take isl_local_space *ls);
+ __isl_give isl_local_space *isl_local_space_range(
+ __isl_take isl_local_space *ls);
__isl_give isl_local_space *isl_local_space_from_domain(
__isl_take isl_local_space *ls);
+ __isl_give isl_local_space *isl_local_space_intersect(
+ __isl_take isl_local_space *ls1,
+ __isl_take isl_local_space *ls2);
__isl_give isl_local_space *isl_local_space_add_dims(
__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned n);
const char *isl_basic_map_get_tuple_name(
__isl_keep isl_basic_map *bmap,
enum isl_dim_type type);
+ __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
+ __isl_take isl_basic_map *bmap,
+ enum isl_dim_type type, const char *s);
const char *isl_map_get_tuple_name(
__isl_keep isl_map *map,
enum isl_dim_type type);
enum isl_dim_type type, __isl_keep isl_id *id);
int isl_map_find_dim_by_id(__isl_keep isl_map *map,
enum isl_dim_type type, __isl_keep isl_id *id);
+ int isl_set_find_dim_by_name(__isl_keep isl_set *set,
+ enum isl_dim_type type, const char *name);
int isl_map_find_dim_by_name(__isl_keep isl_map *map,
enum isl_dim_type type, const char *name);
To check whether a set is a parameter domain, use this function:
int isl_set_is_params(__isl_keep isl_set *set);
+ int isl_union_set_is_params(
+ __isl_keep isl_union_set *uset);
=item * Wrapping
__isl_take isl_map *bmap);
__isl_give isl_set *isl_map_range(
__isl_take isl_map *map);
+ __isl_give isl_set *isl_union_set_params(
+ __isl_take isl_union_set *uset);
+ __isl_give isl_set *isl_union_map_params(
+ __isl_take isl_union_map *umap);
__isl_give isl_union_set *isl_union_map_domain(
__isl_take isl_union_map *umap);
__isl_give isl_union_set *isl_union_map_range(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type,
unsigned first, unsigned n);
+ __isl_give isl_map *isl_map_eliminate(
+ __isl_take isl_map *map, enum isl_dim_type type,
+ unsigned first, unsigned n);
Eliminate the coefficients for the given dimensions from the constraints,
without removing the dimensions.
Intersect the set or relation with the hyperplane where the given
dimension has the fixed given value.
+ __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
+ __isl_take isl_basic_map *bmap,
+ enum isl_dim_type type, unsigned pos, int value);
+ __isl_give isl_set *isl_set_lower_bound_si(
+ __isl_take isl_set *set,
+ enum isl_dim_type type, unsigned pos, int value);
+ __isl_give isl_map *isl_map_lower_bound_si(
+ __isl_take isl_map *map,
+ enum isl_dim_type type, unsigned pos, int value);
+ __isl_give isl_set *isl_set_upper_bound_si(
+ __isl_take isl_set *set,
+ enum isl_dim_type type, unsigned pos, int value);
+ __isl_give isl_map *isl_map_upper_bound_si(
+ __isl_take isl_map *map,
+ enum isl_dim_type type, unsigned pos, int value);
+
+Intersect the set or relation with the half-space where the given
+dimension has a value bounded the fixed given value.
+
__isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);
__isl_give isl_union_set *isl_union_set_lift(
__isl_take isl_union_set *uset);
+Given a local space that contains the existentially quantified
+variables of a set, a basic relation that, when applied to
+a basic set, has essentially the same effect as C<isl_basic_set_lift>,
+can be constructed using the following function.
+
+ #include <isl/local_space.h>
+ __isl_give isl_basic_map *isl_local_space_lifting(
+ __isl_take isl_local_space *ls);
+
=item * Internal Product
__isl_give isl_basic_map *isl_basic_map_zip(
=item * Intersection
+ __isl_give isl_basic_set *isl_basic_set_intersect_params(
+ __isl_take isl_basic_set *bset1,
+ __isl_take isl_basic_set *bset2);
__isl_give isl_basic_set *isl_basic_set_intersect(
__isl_take isl_basic_set *bset1,
__isl_take isl_basic_set *bset2);
__isl_give isl_set *isl_set_intersect(
__isl_take isl_set *set1,
__isl_take isl_set *set2);
+ __isl_give isl_union_set *isl_union_set_intersect_params(
+ __isl_take isl_union_set *uset,
+ __isl_take isl_set *set);
+ __isl_give isl_union_map *isl_union_map_intersect_params(
+ __isl_take isl_union_map *umap,
+ __isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_intersect(
__isl_take isl_union_set *uset1,
__isl_take isl_union_set *uset2);
__isl_give isl_map *isl_map_subtract(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
+ __isl_give isl_map *isl_map_subtract_domain(
+ __isl_take isl_map *map,
+ __isl_take isl_set *dom);
+ __isl_give isl_map *isl_map_subtract_range(
+ __isl_take isl_map *map,
+ __isl_take isl_set *dom);
__isl_give isl_union_set *isl_union_set_subtract(
__isl_take isl_union_set *uset1,
__isl_take isl_union_set *uset2);
__isl_give isl_union_set *isl_union_set_gist(
__isl_take isl_union_set *uset,
__isl_take isl_union_set *context);
+ __isl_give isl_union_set *isl_union_set_gist_params(
+ __isl_take isl_union_set *uset,
+ __isl_take isl_set *set);
__isl_give isl_basic_map *isl_basic_map_gist(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_map *context);
__isl_give isl_map *isl_map_gist_params(
__isl_take isl_map *map,
__isl_take isl_set *context);
+ __isl_give isl_map *isl_map_gist_domain(
+ __isl_take isl_map *map,
+ __isl_take isl_set *context);
+ __isl_give isl_map *isl_map_gist_range(
+ __isl_take isl_map *map,
+ __isl_take isl_set *context);
__isl_give isl_union_map *isl_union_map_gist(
__isl_take isl_union_map *umap,
__isl_take isl_union_map *context);
+ __isl_give isl_union_map *isl_union_map_gist_params(
+ __isl_take isl_union_map *umap,
+ __isl_take isl_set *set);
+ __isl_give isl_union_map *isl_union_map_gist_domain(
+ __isl_take isl_union_map *umap,
+ __isl_take isl_union_set *uset);
The gist operation returns a set or relation that has the
same intersection with the context as the input set or relation.
const char *isl_pw_aff_get_dim_name(
__isl_keep isl_pw_aff *pa,
enum isl_dim_type type, unsigned pos);
+ int isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
+ enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_pw_aff_get_dim_id(
__isl_keep isl_pw_aff *pa,
enum isl_dim_type type, unsigned pos);
__isl_give isl_pw_aff *isl_pw_aff_coalesce(
__isl_take isl_pw_aff *pwqp);
+ __isl_give isl_aff *isl_aff_align_params(
+ __isl_take isl_aff *aff,
+ __isl_take isl_space *model);
__isl_give isl_pw_aff *isl_pw_aff_align_params(
__isl_take isl_pw_aff *pwaff,
__isl_take isl_space *model);
+ __isl_give isl_aff *isl_aff_project_domain_on_params(
+ __isl_take isl_aff *aff);
+
+ __isl_give isl_aff *isl_aff_gist_params(
+ __isl_take isl_aff *aff,
+ __isl_take isl_set *context);
__isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
__isl_take isl_set *context);
+ __isl_give isl_pw_aff *isl_pw_aff_gist_params(
+ __isl_take isl_pw_aff *pwaff,
+ __isl_take isl_set *context);
__isl_give isl_pw_aff *isl_pw_aff_gist(
__isl_take isl_pw_aff *pwaff,
__isl_take isl_set *context);
__isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
__isl_take isl_pw_aff *pa,
__isl_take isl_set *set);
+ __isl_give isl_pw_aff *isl_pw_aff_intersect_params(
+ __isl_take isl_pw_aff *pa,
+ __isl_take isl_set *set);
__isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_pw_aff *isl_pw_aff_union_max(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
+ __isl_give isl_pw_aff *isl_pw_aff_union_add(
+ __isl_take isl_pw_aff *pwaff1,
+ __isl_take isl_pw_aff *pwaff2);
The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
expression with a domain that is the union of those of C<pwaff1> and
enum isl_dim_type type);
__isl_give isl_aff *isl_multi_aff_get_aff(
__isl_keep isl_multi_aff *multi, int pos);
+ __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
+ __isl_keep isl_pw_multi_aff *pma, int pos);
const char *isl_pw_multi_aff_get_dim_name(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type, unsigned pos);
__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_multi_aff *isl_multi_aff_set_tuple_id(
+ __isl_take isl_multi_aff *maff,
+ enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
__isl_take isl_pw_multi_aff *pma,
enum isl_dim_type type, __isl_take isl_id *id);
+ __isl_give isl_multi_aff *isl_multi_aff_drop_dims(
+ __isl_take isl_multi_aff *maff,
+ enum isl_dim_type type, unsigned first, unsigned n);
+
To check whether two multiple affine expressions are
obviously equal to each other, use
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
+ __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
+ __isl_take isl_pw_multi_aff *pma1,
+ __isl_take isl_pw_multi_aff *pma2);
__isl_give isl_multi_aff *isl_multi_aff_scale(
__isl_take isl_multi_aff *maff,
isl_int f);
+ __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
+ __isl_take isl_pw_multi_aff *pma,
+ __isl_take isl_set *set);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_set *set);
+ __isl_give isl_multi_aff *isl_multi_aff_lift(
+ __isl_take isl_multi_aff *maff,
+ __isl_give isl_local_space **ls);
+ __isl_give isl_multi_aff *isl_multi_aff_gist_params(
+ __isl_take isl_multi_aff *maff,
+ __isl_take isl_set *context);
__isl_give isl_multi_aff *isl_multi_aff_gist(
__isl_take isl_multi_aff *maff,
__isl_take isl_set *context);
+ __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
+ __isl_take isl_pw_multi_aff *pma,
+ __isl_take isl_set *set);
+ __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
+ __isl_take isl_pw_multi_aff *pma,
+ __isl_take isl_set *set);
+
+If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
+then it is assigned the local space that lies at the basis of
+the lifting applied.
An expression can be read from input using
The coordinates of a point can be inspected, set and changed
using
- void isl_point_get_coordinate(__isl_keep isl_point *pnt,
+ int isl_point_get_coordinate(__isl_keep isl_point *pnt,
enum isl_dim_type type, int pos, isl_int *v);
__isl_give isl_point *isl_point_set_coordinate(
__isl_take isl_point *pnt,
[n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
-=head3 Printing (Piecewise) Quasipolynomials
+=head3 Input and Output
+
+Piecewise quasipolynomials can be read from input using
+
+ __isl_give isl_union_pw_qpolynomial *
+ isl_union_pw_qpolynomial_read_from_str(
+ isl_ctx *ctx, const char *str);
Quasipolynomials and piecewise quasipolynomials can be printed
using the following functions.
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_domain(
__isl_take isl_pw_qpolynomial *pwpq,
__isl_take isl_set *set);
+ __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_params(
+ __isl_take isl_pw_qpolynomial *pwpq,
+ __isl_take isl_set *set);
__isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
__isl_take isl_union_pw_qpolynomial *upwqp);
__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_intersect_domain(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_union_set *uset);
+ __isl_give isl_union_pw_qpolynomial *
+ isl_union_pw_qpolynomial_intersect_params(
+ __isl_take isl_union_pw_qpolynomial *upwpq,
+ __isl_take isl_set *set);
__isl_give isl_qpolynomial *isl_qpolynomial_align_params(
__isl_take isl_qpolynomial *qp,
__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
__isl_take isl_union_pw_qpolynomial *upwqp);
+ __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
+ __isl_take isl_qpolynomial *qp,
+ __isl_take isl_set *context);
__isl_give isl_qpolynomial *isl_qpolynomial_gist(
__isl_take isl_qpolynomial *qp,
__isl_take isl_set *context);
+ __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
+ __isl_take isl_pw_qpolynomial *pwqp,
+ __isl_take isl_set *context);
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
__isl_take isl_pw_qpolynomial *pwqp,
__isl_take isl_set *context);
+ __isl_give isl_union_pw_qpolynomial *
+ isl_union_pw_qpolynomial_gist_params(
+ __isl_take isl_union_pw_qpolynomial *upwqp,
+ __isl_take isl_set *context);
__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
__isl_take isl_union_pw_qpolynomial *upwqp,
__isl_take isl_union_set *context);
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_point *pnt);
+ __isl_give isl_pw_qpolynomial_fold *
+ sl_pw_qpolynomial_fold_intersect_params(
+ __isl_take isl_pw_qpolynomial_fold *pwf,
+ __isl_take isl_set *set);
+
__isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
__isl_take isl_union_pw_qpolynomial_fold *upwf);
__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_intersect_domain(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_union_set *uset);
+ __isl_give isl_union_pw_qpolynomial_fold *
+ isl_union_pw_qpolynomial_fold_intersect_params(
+ __isl_take isl_union_pw_qpolynomial_fold *upwf,
+ __isl_take isl_set *set);
__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_project_domain_on_params(
__isl_take isl_pw_qpolynomial_fold *pwf);
__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_coalesce(
__isl_take isl_union_pw_qpolynomial_fold *upwf);
+ __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist_params(
+ __isl_take isl_qpolynomial_fold *fold,
+ __isl_take isl_set *context);
+ __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
+ __isl_take isl_qpolynomial_fold *fold,
+ __isl_take isl_set *context);
+
__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_set *context);
+ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist_params(
+ __isl_take isl_pw_qpolynomial_fold *pwf,
+ __isl_take isl_set *context);
__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_gist(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_union_set *context);
+ __isl_give isl_union_pw_qpolynomial_fold *
+ isl_union_pw_qpolynomial_fold_gist_params(
+ __isl_take isl_union_pw_qpolynomial_fold *upwf,
+ __isl_take isl_set *context);
The gist operation applies the gist operation to each of
the cells in the domain of the input piecewise quasipolynomial reduction.
of which of the source access relations was the last
to access the same data element before the given iteration
of the sink access.
+The resulting dependence relations map source iterations
+to the corresponding sink iterations.
To compute standard flow dependences, the sink should be
a read, while the sources should be writes.
If any of the source accesses are marked as being I<may>
-accesses, then there will be a dependence to the last
-I<must> access B<and> to any I<may> access that follows
+accesses, then there will be a dependence from the last
+I<must> access B<and> from any I<may> access that follows
this last I<must> access.
In particular, if I<all> sources are I<may> accesses,
then memory based dependence analysis is performed.
or C<may_no_source> may be C<NULL>, but a C<NULL> value for
any of the other arguments is treated as an error.
+=head3 Interaction with Dependence Analysis
+
+During the dependence analysis, we frequently need to perform
+the following operation. Given a relation between sink iterations
+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 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
+the corresponding potential source iterations being executed.
+If so, we can introduce extra parameters and select an unknown
+but fixed source iteration from the potential source iterations.
+To be able to perform such manipulations, C<isl> provides the following
+function.
+
+ #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(
+ __isl_take isl_access_info *acc,
+ isl_access_restrict_sources fn);
+
+The function C<isl_access_info_set_restrict_sources> should be called
+before 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
+
+ isl_set_universe(
+ isl_space_range(isl_map_get_space(source_map)));
+
+If any error occurs, the callback should return C<NULL>.
+
=head2 Scheduling
B<The functionality described in this section is fairly new
and may be subject to change.>
The following function can be used to compute a schedule
-for a union of domains. The generated schedule respects
-all C<validity> dependences. That is, all dependence distances
-over these dependences in the scheduled space are lexicographically
-positive. The generated schedule schedule also tries to minimize
-the dependence distances over C<proximity> dependences.
+for a union of domains.
+By default, the algorithm used to construct the schedule is similar
+to that of C<Pluto>.
+Alternatively, Feautrier's multi-dimensional scheduling algorithm can
+be selected.
+The generated schedule respects all C<validity> dependences.
+That is, all dependence distances over these dependences in the
+scheduled space are lexicographically positive.
+The default algorithm tries to minimize the dependence distances over
+C<proximity> dependences.
Moreover, it tries to obtain sequences (bands) of schedule dimensions
for groups of domains where the dependence distances have only
non-negative values.
-The algorithm used to construct the schedule is similar to that
-of C<Pluto>.
+When using Feautrier's algorithm, the C<proximity> dependence
+distances are only minimized during the extension to a
+full-dimensional schedule.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_union_set_compute_schedule(
__isl_take isl_printer *p,
__isl_keep isl_band *band);
+=head3 Options
+
+ #include <isl/schedule.h>
+ int isl_options_set_schedule_max_constant_term(
+ isl_ctx *ctx, int val);
+ int isl_options_get_schedule_max_constant_term(
+ isl_ctx *ctx);
+ int isl_options_set_schedule_maximize_band_depth(
+ isl_ctx *ctx, int val);
+ int isl_options_get_schedule_maximize_band_depth(
+ isl_ctx *ctx);
+ int isl_options_set_schedule_outer_zero_distance(
+ isl_ctx *ctx, int val);
+ int isl_options_get_schedule_outer_zero_distance(
+ isl_ctx *ctx);
+ int isl_options_set_schedule_split_parallel(
+ isl_ctx *ctx, int val);
+ int isl_options_get_schedule_split_parallel(
+ isl_ctx *ctx);
+ int isl_options_set_schedule_algorithm(
+ isl_ctx *ctx, int val);
+ int isl_options_get_schedule_algorithm(
+ isl_ctx *ctx);
+
+
+=over
+
+=item * schedule_max_constant_term
+
+This option enforces that the constant coefficients in the calculated schedule
+are not larger than the maximal constant term. This option can significantly
+increase the speed of the scheduling calculation and may also prevent fusing of
+unrelated dimensions. A value of -1 means that this option does not introduce
+bounds on the constant coefficients.
+
+=item * schedule_maximize_band_depth
+
+If this option is set, we do not split bands at the point
+where we detect splitting is necessary. Instead, we
+backtrack and split bands as early as possible. This
+reduces the number of splits and maximizes the width of
+the bands. Wider bands give more possibilities for tiling.
+
+=item * schedule_outer_zero_distance
+
+If this option is set, then we try to construct schedules
+where the outermost scheduling dimension in each band
+results in a zero dependence distance over the proximity
+dependences.
+
+=item * schedule_split_parallel
+
+If this option is set, then we try to construct schedules in which the
+constant term is split off from the linear part if the linear parts of
+the scheduling rows for all nodes in the graphs are the same.
+The constant term is then placed in a separate band and the linear
+part is simplified.
+
+=item * schedule_algorithm
+
+Selects the scheduling algorithm to be used.
+Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
+and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
+
+=back
+
=head2 Parametric Vertex Enumeration
The parametric vertex enumeration described in this section
projects / platform / upstream / isl.git / blobdiff