=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_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);
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
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(
=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
-It this option is set, then we try to construct schedules
+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
projects / platform / upstream / isl.git / blobdiff