Introduction

isl is a thread-safe C library for manipulating sets and relations of integer points bounded by affine constraints. The descriptions of the sets and relations may involve both parameters and existentially quantified variables. All computations are performed in exact integer arithmetic using GMP or imath. The isl library offers functionality that is similar to that offered by the Omega and Omega+ libraries, but the underlying algorithms are in most cases completely different.

The library is by no means complete and some fairly basic functionality is still missing. Still, even in its current form, the library has been successfully used as a backend polyhedral library for the polyhedral scanner CLooG and as part of an equivalence checker of static affine programs. For bug reports, feature requests and questions, visit the discussion group at http://groups.google.com/group/isl-development.

Backward Incompatible Changes

Changes since isl-0.02

Changes since isl-0.03

Changes since isl-0.04

Changes since isl-0.05

Changes since isl-0.06

Changes since isl-0.07

Changes since isl-0.09

Changes since isl-0.10

Changes since isl-0.12

Changes since isl-0.14

Changes since isl-0.17

Changes since isl-0.19

Changes since isl-0.20

License

isl is released under the MIT license.

Note that by default isl requires GMP, which is released under the GNU Lesser General Public License (LGPL). This means that code linked against isl is also linked against LGPL code.

When configuring with --with-int=imath or --with-int=imath-32, isl will link against imath, a library for exact integer arithmetic released under the MIT license.

Installation

The source of isl can be obtained either as a tarball or from the git repository. Both are available from https://libisl.sourceforge.io/. The installation process depends on how you obtained the source.

Installation from the git repository

1 Clone or update the repository

The first time the source is obtained, you need to clone the repository.

git clone git://repo.or.cz/isl.git

To obtain updates, you need to pull in the latest changes

git pull
2 Optionally get imath submodule

To build isl with imath, you need to obtain the imath submodule by running in the git source tree of isl

git submodule init
git submodule update

This will fetch the required version of imath in a subdirectory of isl.

2 Generate configure
./autogen.sh

After performing the above steps, continue with the "Common installation instructions".

Common installation instructions

1 Obtain GMP

By default, building isl requires GMP, including its headers files. Your distribution may not provide these header files by default and you may need to install a package called gmp-devel or something similar. Alternatively, GMP can be built from source, available from http://gmplib.org/. GMP is not needed if you build isl with imath.

2 Configure

isl uses the standard autoconf configure script. To run it, just type

./configure

optionally followed by some configure options. A complete list of options can be obtained by running

./configure --help

Below we discuss some of the more common options.

--prefix

Installation prefix for isl

--with-int=[gmp|imath|imath-32]

Select the integer library to be used by isl, the default is gmp. With imath-32, isl will use 32 bit integers, but fall back to imath for values out of the 32 bit range. In most applications, isl will run fastest with the imath-32 option, followed by gmp and imath, the slowest.

--with-gmp-prefix=path

Installation prefix for GMP (architecture-independent files).

--with-gmp-exec-prefix=path

Installation prefix for GMP (architecture-dependent files).

3 Compile
make
4 Test (optional)
make check
5 Install (optional)
make install

Building the foreign language bindings

The tarball already contains the generated foreign language bindings, but they are not included in the git repository. Building the C++ and Python bindings relies on the LLVM/clang libraries, see http://clang.llvm.org/get_started.html. The configure script will not assume that these are available on the system. To enable building the foreign language bindings, one of the following options needs to be specified.

--with-clang=system

Use the system clang libraries (installed in a default location).

--with-clang-prefix=path

Use the system clang libraries installed in path.

It is best to use the latest release of the clang libraries (16.0), although any release since 3.5 should work as well. Note that if you build the clang libraries from source, then you need to make sure they are also installed (using make install). If the compiler that was used to compile the clang libraries is different from the default C++ compiler, then use CXX_FOR_BUILD to specify this non-default C++ compiler when running isl's ./configure.

Integer Set Library

Memory Management

Since a high-level operation on isl objects usually involves several substeps and since the user is usually not interested in the intermediate results, most functions that return a new object will also release all the objects passed as arguments. If the user still wants to use one or more of these arguments after the function call, she should pass along a copy of the object rather than the object itself. The user is then responsible for making sure that the original object gets used somewhere else or is explicitly freed.

The arguments and return values of all documented functions are annotated to make clear which arguments are released and which arguments are preserved. In particular, the following annotations are used

__isl_give

__isl_give means that a new object is returned. The user should make sure that the returned pointer is used exactly once as a value for an __isl_take argument. In between, it can be used as a value for as many __isl_keep arguments as the user likes. There is one exception, and that is the case where the pointer returned is NULL. In this case, the user is free to use it as an __isl_take argument or not. When applied to a char *, the returned pointer needs to be freed using free.

__isl_null

__isl_null means that a NULL value is returned.

__isl_take

__isl_take means that the object the argument points to is taken over by the function and may no longer be used by the user as an argument to any other function. The pointer value must be one returned by a function returning an __isl_give pointer. If the user passes in a NULL value, then this will be treated as an error in the sense that the function will not perform its usual operation. However, it will still make sure that all the other __isl_take arguments are released.

__isl_keep

__isl_keep means that the function will only use the object temporarily. After the function has finished, the user can still use it as an argument to other functions. A NULL value will be treated in the same way as a NULL value for an __isl_take argument. This annotation may also be used on return values of type const char *, in which case the returned pointer should not be freed by the user and is only valid until the object from which it was derived is updated or freed.

Initialization

All manipulations of integer sets and relations occur within the context of an isl_ctx. A given isl_ctx can only be used within a single thread. All arguments of a function are required to have been allocated within the same context. There are currently no functions available for moving an object from one isl_ctx to another isl_ctx. This means that there is currently no way of safely moving an object from one thread to another, unless the whole isl_ctx is moved.

An isl_ctx can be allocated using isl_ctx_alloc and freed using isl_ctx_free. All objects allocated within an isl_ctx should be freed before the isl_ctx itself is freed.

isl_ctx *isl_ctx_alloc();
void isl_ctx_free(isl_ctx *ctx);

The user can impose a bound on the number of low-level operations that can be performed by an isl_ctx. This bound can be set and retrieved using the following functions. A bound of zero means that no bound is imposed. The number of operations performed can be reset using isl_ctx_reset_operations. Note that the number of low-level operations needed to perform a high-level computation may differ significantly across different versions of isl, but it should be the same across different platforms for the same version of isl.

Warning: This feature is experimental. isl has good support to abort and bail out during the computation, but this feature may exercise error code paths that are normally not used that much. Consequently, it is not unlikely that hidden bugs will be exposed.

void isl_ctx_set_max_operations(isl_ctx *ctx,
        unsigned long max_operations);
unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
void isl_ctx_reset_operations(isl_ctx *ctx);

In order to be able to create an object in the same context as another object, most object types (described later in this document) provide a function to obtain the context in which the object was created.

#include <isl/val.h>
isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
isl_ctx *isl_multi_val_get_ctx(
        __isl_keep isl_multi_val *mv);

#include <isl/id.h>
isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
isl_ctx *isl_multi_id_get_ctx(
        __isl_keep isl_multi_id *mi);

#include <isl/local_space.h>
isl_ctx *isl_local_space_get_ctx(
        __isl_keep isl_local_space *ls);

#include <isl/set.h>
isl_ctx *isl_set_list_get_ctx(
        __isl_keep isl_set_list *list);

#include <isl/aff.h>
isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
isl_ctx *isl_multi_aff_get_ctx(
        __isl_keep isl_multi_aff *maff);
isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pa);
isl_ctx *isl_pw_multi_aff_get_ctx(
        __isl_keep isl_pw_multi_aff *pma);
isl_ctx *isl_multi_pw_aff_get_ctx(
        __isl_keep isl_multi_pw_aff *mpa);
isl_ctx *isl_union_pw_aff_get_ctx(
        __isl_keep isl_union_pw_aff *upa);
isl_ctx *isl_union_pw_multi_aff_get_ctx(
        __isl_keep isl_union_pw_multi_aff *upma);
isl_ctx *isl_multi_union_pw_aff_get_ctx(
        __isl_keep isl_multi_union_pw_aff *mupa);

#include <isl/id_to_ast_expr.h>
isl_ctx *isl_id_to_ast_expr_get_ctx(
        __isl_keep isl_id_to_ast_expr *id2expr);

#include <isl/point.h>
isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);

#include <isl/vec.h>
isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);

#include <isl/mat.h>
isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);

#include <isl/vertices.h>
isl_ctx *isl_vertices_get_ctx(
        __isl_keep isl_vertices *vertices);
isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);

#include <isl/flow.h>
isl_ctx *isl_restriction_get_ctx(
        __isl_keep isl_restriction *restr);
isl_ctx *isl_union_access_info_get_ctx(
        __isl_keep isl_union_access_info *access);
isl_ctx *isl_union_flow_get_ctx(
        __isl_keep isl_union_flow *flow);

#include <isl/schedule.h>
isl_ctx *isl_schedule_get_ctx(
        __isl_keep isl_schedule *sched);
isl_ctx *isl_schedule_constraints_get_ctx(
        __isl_keep isl_schedule_constraints *sc);

#include <isl/schedule_node.h>
isl_ctx *isl_schedule_node_get_ctx(
        __isl_keep isl_schedule_node *node);

#include <isl/ast_build.h>
isl_ctx *isl_ast_build_get_ctx(
        __isl_keep isl_ast_build *build);

#include <isl/ast.h>
isl_ctx *isl_ast_expr_get_ctx(
        __isl_keep isl_ast_expr *expr);
isl_ctx *isl_ast_node_get_ctx(
        __isl_keep isl_ast_node *node);

#include <isl/stride_info.h>
isl_ctx *isl_stride_info_get_ctx(
        __isl_keep isl_stride_info *si);

#include <isl/fixed_box.h>
isl_ctx *isl_fixed_box_get_ctx(
        __isl_keep isl_fixed_box *box);

Return Types

isl uses the special return type isl_size for functions that return a non-negative value, typically a number or a position. Besides the regular non-negative return values, a special (negative) value isl_size_error may be returned, indicating that something went wrong.

isl also uses two special return types for functions that either return a boolean or that in principle do not return anything. In particular, the isl_bool type has three possible values: isl_bool_true (a positive integer value), indicating true or yes; isl_bool_false (the integer value zero), indicating false or no; and isl_bool_error (a negative integer value), indicating that something went wrong. The following operations are defined on isl_bool. The function isl_bool_not can be used to negate an isl_bool, where the negation of isl_bool_error is isl_bool_error again. The function isl_bool_ok converts an integer to an isl_bool. Any non-zero values yields isl_bool_true and zero yields isl_bool_false.

#include <isl/ctx.h>
isl_bool isl_bool_not(isl_bool b);
isl_bool isl_bool_ok(int b);

The isl_stat type has two possible values: isl_stat_ok (the integer value zero), indicating a successful operation; and isl_stat_error (a negative integer value), indicating that something went wrong. The function isl_stat_non_null converts an isl object pointer to an isl_stat, returning isl_stat_ok if the object pointer is valid and isl_stat_error if it is NULL.

#include <isl/ctx.h>
isl_stat isl_stat_non_null(void *obj);

See "Error Handling" for more information on isl_size_error, isl_bool_error and isl_stat_error.

Values

An isl_val represents an integer value, a rational value or one of three special values, infinity, negative infinity and NaN. Some predefined values can be created using the following functions.

#include <isl/val.h>
__isl_give isl_val *isl_val_zero(isl_ctx *ctx);
__isl_give isl_val *isl_val_one(isl_ctx *ctx);
__isl_give isl_val *isl_val_negone(isl_ctx *ctx);
__isl_give isl_val *isl_val_nan(isl_ctx *ctx);
__isl_give isl_val *isl_val_infty(isl_ctx *ctx);
__isl_give isl_val *isl_val_neginfty(isl_ctx *ctx);

Specific integer values can be created using the following functions.

#include <isl/val.h>
__isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx,
        long i);
__isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx,
        unsigned long u);
__isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx,
        size_t n, size_t size, const void *chunks);

The function isl_val_int_from_chunks constructs an isl_val from the n digits, each consisting of size bytes, stored at chunks. The least significant digit is assumed to be stored first.

Value objects can be copied and freed using the following functions.

#include <isl/val.h>
__isl_give isl_val *isl_val_copy(__isl_keep isl_val *v);
__isl_null isl_val *isl_val_free(__isl_take isl_val *v);

They can be inspected using the following functions.

#include <isl/val.h>
long isl_val_get_num_si(__isl_keep isl_val *v);
long isl_val_get_den_si(__isl_keep isl_val *v);
__isl_give isl_val *isl_val_get_den_val(
        __isl_keep isl_val *v);
double isl_val_get_d(__isl_keep isl_val *v);
isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
        size_t size);
isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
        size_t size, void *chunks);

isl_val_n_abs_num_chunks returns the number of digits of size bytes needed to store the absolute value of the numerator of v. isl_val_get_abs_num_chunks stores these digits at chunks, which is assumed to have been preallocated by the caller. The least significant digit is stored first. Note that isl_val_get_num_si, isl_val_get_den_si, isl_val_get_d, isl_val_n_abs_num_chunks and isl_val_get_abs_num_chunks can only be applied to rational values.

An isl_val can be modified using the following function.

#include <isl/val.h>
__isl_give isl_val *isl_val_set_si(__isl_take isl_val *v,
        long i);

The following unary properties are defined on isl_vals.

#include <isl/val.h>
int isl_val_sgn(__isl_keep isl_val *v);
isl_bool isl_val_is_zero(__isl_keep isl_val *v);
isl_bool isl_val_is_one(__isl_keep isl_val *v);
isl_bool isl_val_is_negone(__isl_keep isl_val *v);
isl_bool isl_val_is_nonneg(__isl_keep isl_val *v);
isl_bool isl_val_is_nonpos(__isl_keep isl_val *v);
isl_bool isl_val_is_pos(__isl_keep isl_val *v);
isl_bool isl_val_is_neg(__isl_keep isl_val *v);
isl_bool isl_val_is_int(__isl_keep isl_val *v);
isl_bool isl_val_is_rat(__isl_keep isl_val *v);
isl_bool isl_val_is_nan(__isl_keep isl_val *v);
isl_bool isl_val_is_infty(__isl_keep isl_val *v);
isl_bool isl_val_is_neginfty(__isl_keep isl_val *v);

Note that the sign of NaN is undefined.

The following binary properties are defined on pairs of isl_vals.

#include <isl/val.h>
isl_bool isl_val_lt(__isl_keep isl_val *v1,
        __isl_keep isl_val *v2);
isl_bool isl_val_le(__isl_keep isl_val *v1,
        __isl_keep isl_val *v2);
isl_bool isl_val_gt(__isl_keep isl_val *v1,
        __isl_keep isl_val *v2);
isl_bool isl_val_ge(__isl_keep isl_val *v1,
        __isl_keep isl_val *v2);
isl_bool isl_val_eq(__isl_keep isl_val *v1,
        __isl_keep isl_val *v2);
isl_bool isl_val_ne(__isl_keep isl_val *v1,
        __isl_keep isl_val *v2);
isl_bool isl_val_abs_eq(__isl_keep isl_val *v1,
        __isl_keep isl_val *v2);

Comparisons to NaN always return false. That is, a NaN is not considered to hold any relative position with respect to any value. In particular, a NaN is neither considered to be equal to nor to be different from any value (including another NaN). The function isl_val_abs_eq checks whether its two arguments are equal in absolute value.

For integer isl_vals we additionally have the following binary property.

#include <isl/val.h>
isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1,
        __isl_keep isl_val *v2);

An isl_val can also be compared to an integer using the following functions. The result of isl_val_cmp_si is undefined for NaN.

#include <isl/val.h>
isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i);
isl_bool isl_val_eq_si(__isl_keep isl_val *v, long i);
int isl_val_cmp_si(__isl_keep isl_val *v, long i);

The following unary operations are available on isl_vals.

#include <isl/val.h>
__isl_give isl_val *isl_val_abs(__isl_take isl_val *v);
__isl_give isl_val *isl_val_neg(__isl_take isl_val *v);
__isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
__isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
__isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
__isl_give isl_val *isl_val_inv(__isl_take isl_val *v);

The following binary operations are available on isl_vals.

#include <isl/val.h>
__isl_give isl_val *isl_val_min(__isl_take isl_val *v1,
        __isl_take isl_val *v2);
__isl_give isl_val *isl_val_max(__isl_take isl_val *v1,
        __isl_take isl_val *v2);
__isl_give isl_val *isl_val_add(__isl_take isl_val *v1,
        __isl_take isl_val *v2);
__isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1,
        unsigned long v2);
__isl_give isl_val *isl_val_sub(__isl_take isl_val *v1,
        __isl_take isl_val *v2);
__isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1,
        unsigned long v2);
__isl_give isl_val *isl_val_mul(__isl_take isl_val *v1,
        __isl_take isl_val *v2);
__isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1,
        unsigned long v2);
__isl_give isl_val *isl_val_div(__isl_take isl_val *v1,
        __isl_take isl_val *v2);
__isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1,
        unsigned long v2);

On integer values, we additionally have the following operations.

#include <isl/val.h>
__isl_give isl_val *isl_val_pow2(__isl_take isl_val *v);
__isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
__isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,
        __isl_take isl_val *v2);
__isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1,
        __isl_take isl_val *v2);
__isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
        __isl_take isl_val *v2, __isl_give isl_val **x,
        __isl_give isl_val **y);

isl_val_2exp is an alternative name for isl_val_pow2. The function isl_val_gcdext returns the greatest common divisor g of v1 and v2 as well as two integers *x and *y such that *x * v1 + *y * v2 = g.

GMP specific functions

These functions are only available if isl has been compiled with GMP support.

Specific integer and rational values can be created from GMP values using the following functions.

#include <isl/val_gmp.h>
__isl_give isl_val *isl_val_int_from_gmp(isl_ctx *ctx,
        mpz_t z);
__isl_give isl_val *isl_val_from_gmp(isl_ctx *ctx,
        const mpz_t n, const mpz_t d);

The numerator and denominator of a rational value can be extracted as GMP values using the following functions.

#include <isl/val_gmp.h>
int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z);
int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z);

Sets and Relations

isl uses six types of objects for representing sets and relations, isl_basic_set, isl_basic_map, isl_set, isl_map, isl_union_set and isl_union_map. isl_basic_set and isl_basic_map represent sets and relations that can be described as a conjunction of affine constraints, while isl_set and isl_map represent unions of isl_basic_sets and isl_basic_maps, respectively. However, all isl_basic_sets or isl_basic_maps in the union need to live in the same space. isl_union_sets and isl_union_maps represent unions of isl_sets or isl_maps in different spaces, where spaces are considered different if they have a different number of dimensions and/or different names (see "Spaces"). The difference between sets and relations (maps) is that sets have one set of variables, while relations have two sets of variables, input variables and output variables.

Error Handling

isl supports different ways to react in case a runtime error is triggered. Runtime errors arise, e.g., if a function such as 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, isl prints a warning, stores the last error in the corresponding isl_ctx and the function in which the error was triggered returns a value indicating that some error has occurred. In case of functions returning a pointer, this value is NULL. In case of functions returning an isl_size, isl_bool or an isl_stat, this value is isl_size_error, isl_bool_error or isl_stat_error. An error does not corrupt internal state, such that isl can continue to be used. isl also provides functions to read the last error, including the specific error message, the isl source file where the error occurred and the line number, and to reset all information about the last error. The last error is only stored for information purposes. Its presence does not change the behavior of 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);
const char *isl_ctx_last_error_msg(isl_ctx *ctx);
const char *isl_ctx_last_error_file(isl_ctx *ctx);
int isl_ctx_last_error_line(isl_ctx *ctx);
void isl_ctx_reset_error(isl_ctx *ctx);

If no error has occurred since the last call to isl_ctx_reset_error, then the functions isl_ctx_last_error_msg and isl_ctx_last_error_file return NULL.

Another option is to continue on error. This is similar to warn on error mode, except that 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 isl_options_set_on_error or by setting the command line option --isl-on-error. Valid arguments for the function call are ISL_ON_ERROR_WARN, ISL_ON_ERROR_CONTINUE and ISL_ON_ERROR_ABORT. The choices for the command line option are warn, continue and abort. It is also possible to query the current error mode.

#include <isl/options.h>
isl_stat isl_options_set_on_error(isl_ctx *ctx, int val);
int isl_options_get_on_error(isl_ctx *ctx);

Identifiers

Identifiers are used to identify both individual dimensions and tuples of dimensions. They consist of an optional name and an optional user pointer. The name and the user pointer cannot both be NULL, however. Identifiers with the same name but different pointer values are considered to be distinct. Similarly, identifiers with different names but the same pointer value are also considered to be distinct. Equal identifiers are represented using the same object. Pairs of identifiers can therefore be tested for equality using the == operator. Identifiers can be constructed, copied, freed, inspected and printed using the following functions.

#include <isl/id.h>
__isl_give isl_id *isl_id_alloc(isl_ctx *ctx,
        __isl_keep const char *name, void *user);
__isl_give isl_id *isl_id_set_free_user(
        __isl_take isl_id *id,
        void (*free_user)(void *user));
void (*isl_id_get_free_user(__isl_keep isl_id *id))
        (void *user);
__isl_give isl_id *isl_id_copy(isl_id *id);
__isl_null isl_id *isl_id_free(__isl_take isl_id *id);

void *isl_id_get_user(__isl_keep isl_id *id);
__isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);

__isl_give isl_printer *isl_printer_print_id(
        __isl_take isl_printer *p, __isl_keep isl_id *id);

The callback set by isl_id_set_free_user is called on the user pointer when the last reference to the isl_id is freed. This callback can be retrieved using isl_id_get_free_user. Note that isl_id_get_name returns a pointer to some internal data structure, so the result can only be used while the corresponding isl_id is alive.

Spaces

Whenever a new set, relation or similar object is created from scratch, the space in which it lives needs to be specified using an isl_space. Each space involves zero or more parameters and zero, one or two tuples of set or input/output dimensions. The parameters and dimensions are identified by an isl_dim_type and a position. The type isl_dim_param refers to parameters, the type isl_dim_set refers to set dimensions (for spaces with a single tuple of dimensions) and the types isl_dim_in and isl_dim_out refer to input and output dimensions (for spaces with two tuples of dimensions). Local spaces (see "Local Spaces") also contain dimensions of type isl_dim_div. Note that parameters are only identified by their position within a given object. Across different objects, parameters are (usually) identified by their names or identifiers. Only unnamed parameters are identified by their positions across objects. The use of unnamed parameters is discouraged.

#include <isl/space.h>
__isl_give isl_space *isl_space_unit(isl_ctx *ctx);
__isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
        unsigned nparam, unsigned n_in, unsigned n_out);
__isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,
        unsigned nparam);
__isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
        unsigned nparam, unsigned dim);
__isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
__isl_null isl_space *isl_space_free(__isl_take isl_space *space);

The space used for creating a parameter domain needs to be created using isl_space_unit or isl_space_params_alloc. For other sets, the space needs to be created using isl_space_set_alloc, while for a relation, the space needs to be created using isl_space_alloc. The use of isl_space_params_alloc, isl_space_set_alloc and isl_space_alloc is discouraged as they allow for the introduction of unnamed parameters.

To check whether a given space is that of a set or a map or whether it is a parameter space, use these functions:

#include <isl/space.h>
isl_bool isl_space_is_params(__isl_keep isl_space *space);
isl_bool isl_space_is_set(__isl_keep isl_space *space);
isl_bool isl_space_is_map(__isl_keep isl_space *space);

Spaces can be compared using the following functions:

#include <isl/space.h>
isl_bool isl_space_is_equal(__isl_keep isl_space *space1,
        __isl_keep isl_space *space2);
isl_bool isl_space_has_equal_params(
        __isl_keep isl_space *space1,
        __isl_keep isl_space *space2);
isl_bool isl_space_has_equal_tuples(
        __isl_keep isl_space *space1,
        __isl_keep isl_space *space2);
isl_bool isl_space_is_domain(__isl_keep isl_space *space1,
        __isl_keep isl_space *space2);
isl_bool isl_space_is_range(__isl_keep isl_space *space1,
        __isl_keep isl_space *space2);
isl_bool isl_space_tuple_is_equal(
        __isl_keep isl_space *space1,
        enum isl_dim_type type1,
        __isl_keep isl_space *space2,
        enum isl_dim_type type2);

isl_space_is_domain checks whether the first argument is equal to the domain of the second argument. This requires in particular that the first argument is a set space and that the second argument is a map space. isl_space_tuple_is_equal checks whether the given tuples (isl_dim_in, isl_dim_out or isl_dim_set) of the given spaces are the same. That is, it checks if they have the same identifier (if any), the same dimension and the same internal structure (if any). The function isl_space_has_equal_params checks whether two spaces have the same parameters in the same order. isl_space_has_equal_tuples check whether two spaces have the same tuples. In contrast to isl_space_is_equal below, it does not check the parameters. This is useful because many isl functions align the parameters before they perform their operations, such that equivalence is not necessary. isl_space_is_equal checks whether two spaces are identical, meaning that they have the same parameters and the same tuples. That is, it checks whether both isl_space_has_equal_params and isl_space_has_equal_tuples hold.

It is often useful to create objects that live in the same space as some other object. This can be accomplished by creating the new objects (see "Creating New Sets and Relations" or "Functions") based on the space of the original object.

#include <isl/set.h>
__isl_give isl_space *isl_basic_set_get_space(
        __isl_keep isl_basic_set *bset);
__isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);

#include <isl/union_set.h>
__isl_give isl_space *isl_union_set_get_space(
        __isl_keep isl_union_set *uset);

#include <isl/map.h>
__isl_give isl_space *isl_basic_map_get_space(
        __isl_keep isl_basic_map *bmap);
__isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);

#include <isl/union_map.h>
__isl_give isl_space *isl_union_map_get_space(
        __isl_keep isl_union_map *umap);

#include <isl/constraint.h>
__isl_give isl_space *isl_constraint_get_space(
        __isl_keep isl_constraint *constraint);

#include <isl/polynomial.h>
__isl_give isl_space *isl_qpolynomial_get_domain_space(
        __isl_keep isl_qpolynomial *qp);
__isl_give isl_space *isl_qpolynomial_get_space(
        __isl_keep isl_qpolynomial *qp);
__isl_give isl_space *
isl_qpolynomial_fold_get_domain_space(
        __isl_keep isl_qpolynomial_fold *fold);
__isl_give isl_space *isl_qpolynomial_fold_get_space(
        __isl_keep isl_qpolynomial_fold *fold);
__isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
        __isl_keep isl_pw_qpolynomial *pwqp);
__isl_give isl_space *isl_pw_qpolynomial_get_space(
        __isl_keep isl_pw_qpolynomial *pwqp);
__isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(
        __isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_give isl_space *isl_pw_qpolynomial_fold_get_space(
        __isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_give isl_space *isl_union_pw_qpolynomial_get_space(
        __isl_keep isl_union_pw_qpolynomial *upwqp);
__isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
        __isl_keep isl_union_pw_qpolynomial_fold *upwf);

#include <isl/id.h>
__isl_give isl_space *isl_multi_id_get_space(
        __isl_keep isl_multi_id *mi);

#include <isl/val.h>
__isl_give isl_space *isl_multi_val_get_space(
        __isl_keep isl_multi_val *mv);

#include <isl/aff.h>
__isl_give isl_space *isl_aff_get_domain_space(
        __isl_keep isl_aff *aff);
__isl_give isl_space *isl_aff_get_space(
        __isl_keep isl_aff *aff);
__isl_give isl_space *isl_pw_aff_get_domain_space(
        __isl_keep isl_pw_aff *pwaff);
__isl_give isl_space *isl_pw_aff_get_space(
        __isl_keep isl_pw_aff *pwaff);
__isl_give isl_space *isl_multi_aff_get_domain_space(
        __isl_keep isl_multi_aff *maff);
__isl_give isl_space *isl_multi_aff_get_space(
        __isl_keep isl_multi_aff *maff);
__isl_give isl_space *isl_pw_multi_aff_get_domain_space(
        __isl_keep isl_pw_multi_aff *pma);
__isl_give isl_space *isl_pw_multi_aff_get_space(
        __isl_keep isl_pw_multi_aff *pma);
__isl_give isl_space *isl_union_pw_aff_get_space(
        __isl_keep isl_union_pw_aff *upa);
__isl_give isl_space *isl_union_pw_multi_aff_get_space(
        __isl_keep isl_union_pw_multi_aff *upma);
__isl_give isl_space *isl_multi_pw_aff_get_domain_space(
        __isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_space *isl_multi_pw_aff_get_space(
        __isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_space *
isl_multi_union_pw_aff_get_domain_space(
        __isl_keep isl_multi_union_pw_aff *mupa);
__isl_give isl_space *
isl_multi_union_pw_aff_get_space(
        __isl_keep isl_multi_union_pw_aff *mupa);

#include <isl/point.h>
__isl_give isl_space *isl_point_get_space(
        __isl_keep isl_point *pnt);

#include <isl/fixed_box.h>
__isl_give isl_space *isl_fixed_box_get_space(
        __isl_keep isl_fixed_box *box);

The number of dimensions of a given type of space may be read off from a space or an object that lives in a space using the following functions. In case of isl_space_dim, type may be isl_dim_param, isl_dim_in (only for relations), isl_dim_out (only for relations), isl_dim_set (only for sets) or isl_dim_all.

#include <isl/space.h>
isl_size isl_space_dim(__isl_keep isl_space *space,
        enum isl_dim_type type);

#include <isl/local_space.h>
isl_size isl_local_space_dim(__isl_keep isl_local_space *ls,
        enum isl_dim_type type);

#include <isl/set.h>
isl_size isl_basic_set_dim(__isl_keep isl_basic_set *bset,
        enum isl_dim_type type);
isl_size isl_set_tuple_dim(__isl_keep isl_set *set);
isl_size isl_set_dim(__isl_keep isl_set *set,
        enum isl_dim_type type);

#include <isl/union_set.h>
isl_size isl_union_set_dim(__isl_keep isl_union_set *uset,
        enum isl_dim_type type);

#include <isl/map.h>
isl_size isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
        enum isl_dim_type type);
isl_size isl_map_domain_tuple_dim(
        __isl_keep isl_map *map);
isl_size isl_map_range_tuple_dim(
        __isl_keep isl_map *map);
isl_size isl_map_dim(__isl_keep isl_map *map,
        enum isl_dim_type type);

#include <isl/union_map.h>
isl_size isl_union_map_dim(__isl_keep isl_union_map *umap,
        enum isl_dim_type type);

#include <isl/val.h>
isl_size isl_multi_val_dim(__isl_keep isl_multi_val *mv,
        enum isl_dim_type type);

#include <isl/aff.h>
isl_size isl_aff_dim(__isl_keep isl_aff *aff,
        enum isl_dim_type type);
isl_size isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
        enum isl_dim_type type);
isl_size isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
        enum isl_dim_type type);
isl_size isl_pw_multi_aff_dim(
        __isl_keep isl_pw_multi_aff *pma,
        enum isl_dim_type type);
isl_size isl_multi_pw_aff_dim(
        __isl_keep isl_multi_pw_aff *mpa,
        enum isl_dim_type type);
isl_size isl_union_pw_aff_dim(
        __isl_keep isl_union_pw_aff *upa,
        enum isl_dim_type type);
isl_size isl_union_pw_multi_aff_dim(
        __isl_keep isl_union_pw_multi_aff *upma,
        enum isl_dim_type type);
isl_size isl_multi_union_pw_aff_dim(
        __isl_keep isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type);

#include <isl/polynomial.h>
isl_size isl_union_pw_qpolynomial_dim(
        __isl_keep isl_union_pw_qpolynomial *upwqp,
        enum isl_dim_type type);
isl_size isl_union_pw_qpolynomial_fold_dim(
        __isl_keep isl_union_pw_qpolynomial_fold *upwf,
        enum isl_dim_type type);

Note that an isl_union_set, an isl_union_map, an isl_union_pw_multi_aff, an isl_union_pw_qpolynomial and an isl_union_pw_qpolynomial_fold only have parameters.

Additional parameters can be added to a space using the following function.

#include <isl/space.h>
__isl_give isl_space *isl_space_add_param_id(
        __isl_take isl_space *space,
        __isl_take isl_id *id);

If a parameter with the given identifier already appears in the space, then it is not added again.

Conversely, all parameters can be removed from a space using the following function.

#include <isl/space.h>
__isl_give isl_space *isl_space_drop_all_params(
        __isl_take isl_space *space);

The identifiers or names of the individual dimensions of spaces may be set or read off using the following functions on spaces or objects that live in spaces. These functions are mostly useful to obtain the identifiers, positions or names of the parameters. Identifiers of individual dimensions are essentially only useful for printing. They are ignored by all other operations and may not be preserved across those operations. To keep track of a space along with names/identifiers of the set dimensions, use an isl_multi_id as described in "Functions".

#include <isl/space.h>
__isl_give isl_space *isl_space_set_dim_id(
        __isl_take isl_space *space,
        enum isl_dim_type type, unsigned pos,
        __isl_take isl_id *id);
isl_bool isl_space_has_dim_id(__isl_keep isl_space *space,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_space_get_dim_id(
        __isl_keep isl_space *space,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_space *isl_space_set_dim_name(
        __isl_take isl_space *space,
         enum isl_dim_type type, unsigned pos,
         __isl_keep const char *name);
isl_bool isl_space_has_dim_name(__isl_keep isl_space *space,
        enum isl_dim_type type, unsigned pos);
__isl_keep const char *isl_space_get_dim_name(
        __isl_keep isl_space *space,
        enum isl_dim_type type, unsigned pos);

#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_set_dim_id(
        __isl_take isl_local_space *ls,
        enum isl_dim_type type, unsigned pos,
        __isl_take isl_id *id);
isl_bool isl_local_space_has_dim_id(
        __isl_keep isl_local_space *ls,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_local_space_get_dim_id(
        __isl_keep isl_local_space *ls,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_local_space *isl_local_space_set_dim_name(
        __isl_take isl_local_space *ls,
        enum isl_dim_type type, unsigned pos, const char *s);
isl_bool isl_local_space_has_dim_name(
        __isl_keep isl_local_space *ls,
        enum isl_dim_type type, unsigned pos)
const char *isl_local_space_get_dim_name(
        __isl_keep isl_local_space *ls,
        enum isl_dim_type type, unsigned pos);

#include <isl/constraint.h>
const char *isl_constraint_get_dim_name(
        __isl_keep isl_constraint *constraint,
        enum isl_dim_type type, unsigned pos);

#include <isl/set.h>
__isl_give isl_id *isl_basic_set_get_dim_id(
        __isl_keep isl_basic_set *bset,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_set *isl_set_set_dim_id(
        __isl_take isl_set *set, enum isl_dim_type type,
        unsigned pos, __isl_take isl_id *id);
isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_set_get_dim_id(
        __isl_keep isl_set *set, enum isl_dim_type type,
        unsigned pos);
const char *isl_basic_set_get_dim_name(
        __isl_keep isl_basic_set *bset,
        enum isl_dim_type type, unsigned pos);
isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,
        enum isl_dim_type type, unsigned pos);
const char *isl_set_get_dim_name(
        __isl_keep isl_set *set,
        enum isl_dim_type type, unsigned pos);

#include <isl/map.h>
__isl_give isl_map *isl_map_set_dim_id(
        __isl_take isl_map *map, enum isl_dim_type type,
        unsigned pos, __isl_take isl_id *id);
isl_bool isl_basic_map_has_dim_id(
        __isl_keep isl_basic_map *bmap,
        enum isl_dim_type type, unsigned pos);
isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_map_get_dim_id(
        __isl_keep isl_map *map, enum isl_dim_type type,
        unsigned pos);
__isl_give isl_id *isl_union_map_get_dim_id(
        __isl_keep isl_union_map *umap,
        enum isl_dim_type type, unsigned pos);
const char *isl_basic_map_get_dim_name(
        __isl_keep isl_basic_map *bmap,
        enum isl_dim_type type, unsigned pos);
isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
        enum isl_dim_type type, unsigned pos);
const char *isl_map_get_dim_name(
        __isl_keep isl_map *map,
        enum isl_dim_type type, unsigned pos);

#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_set_dim_id(
        __isl_take isl_multi_val *mv,
        enum isl_dim_type type, unsigned pos,
        __isl_take isl_id *id);
__isl_give isl_id *isl_multi_val_get_dim_id(
        __isl_keep isl_multi_val *mv,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_multi_val *isl_multi_val_set_dim_name(
        __isl_take isl_multi_val *mv,
        enum isl_dim_type type, unsigned pos, const char *s);

#include <isl/aff.h>
__isl_give isl_aff *isl_aff_set_dim_id(
        __isl_take isl_aff *aff, enum isl_dim_type type,
        unsigned pos, __isl_take isl_id *id);
__isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
        __isl_take isl_multi_aff *maff,
        enum isl_dim_type type, unsigned pos,
        __isl_take isl_id *id);
__isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
        __isl_take isl_pw_aff *pma,
        enum isl_dim_type type, unsigned pos,
        __isl_take isl_id *id);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_set_dim_id(
        __isl_take isl_multi_pw_aff *mpa,
        enum isl_dim_type type, unsigned pos,
        __isl_take isl_id *id);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_dim_id(
        __isl_take isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type, unsigned pos,
        __isl_take isl_id *id);
__isl_give isl_id *isl_multi_aff_get_dim_id(
        __isl_keep isl_multi_aff *ma,
        enum isl_dim_type type, unsigned pos);
isl_bool 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_id *isl_pw_multi_aff_get_dim_id(
        __isl_keep isl_pw_multi_aff *pma,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_multi_pw_aff_get_dim_id(
        __isl_keep isl_multi_pw_aff *mpa,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_multi_union_pw_aff_get_dim_id(
        __isl_keep isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_aff *isl_aff_set_dim_name(
        __isl_take isl_aff *aff, enum isl_dim_type type,
        unsigned pos, const char *s);
__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_pw_aff *
isl_multi_pw_aff_set_dim_name(
        __isl_take isl_multi_pw_aff *mpa,
        enum isl_dim_type type, unsigned pos, const char *s);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_set_dim_name(
        __isl_take isl_union_pw_aff *upa,
        enum isl_dim_type type, unsigned pos,
        const char *s);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_set_dim_name(
        __isl_take isl_union_pw_multi_aff *upma,
        enum isl_dim_type type, unsigned pos,
        const char *s);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_dim_name(
        __isl_take isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type, unsigned pos,
        const char *s);
const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
        enum isl_dim_type type, unsigned pos);
const char *isl_pw_aff_get_dim_name(
        __isl_keep isl_pw_aff *pa,
        enum isl_dim_type type, unsigned pos);
const char *isl_pw_multi_aff_get_dim_name(
        __isl_keep isl_pw_multi_aff *pma,
        enum isl_dim_type type, unsigned pos);

#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
        __isl_take isl_qpolynomial *qp,
        enum isl_dim_type type, unsigned pos,
        const char *s);
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_set_dim_name(
        __isl_take isl_pw_qpolynomial *pwqp,
        enum isl_dim_type type, unsigned pos,
        const char *s);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_set_dim_name(
        __isl_take isl_pw_qpolynomial_fold *pwf,
        enum isl_dim_type type, unsigned pos,
        const char *s);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_set_dim_name(
        __isl_take isl_union_pw_qpolynomial *upwqp,
        enum isl_dim_type type, unsigned pos,
        const char *s);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_set_dim_name(
        __isl_take isl_union_pw_qpolynomial_fold *upwf,
        enum isl_dim_type type, unsigned pos,
        const char *s);

Note that isl_space_get_name returns a pointer to some internal data structure, so the result can only be used while the corresponding isl_space is alive. Also note that every function that operates on two sets or relations requires that both arguments have the same parameters. This also means that if one of the arguments has named parameters, then the other needs to have named parameters too and the names need to match. Pairs of isl_set, isl_map, isl_union_set and/or isl_union_map arguments may have different parameters (as long as they are named), in which case the result will have as parameters the union of the parameters of the arguments.

Given the identifier or name of a dimension (typically a parameter), its position can be obtained from the following functions.

#include <isl/space.h>
int isl_space_find_dim_by_id(__isl_keep isl_space *space,
        enum isl_dim_type type, __isl_keep isl_id *id);
int isl_space_find_dim_by_name(__isl_keep isl_space *space,
        enum isl_dim_type type, const char *name);

#include <isl/local_space.h>
int isl_local_space_find_dim_by_name(
        __isl_keep isl_local_space *ls,
        enum isl_dim_type type, const char *name);

#include <isl/val.h>
int isl_multi_val_find_dim_by_id(
        __isl_keep isl_multi_val *mv,
        enum isl_dim_type type, __isl_keep isl_id *id);
int isl_multi_val_find_dim_by_name(
        __isl_keep isl_multi_val *mv,
        enum isl_dim_type type, const char *name);

#include <isl/set.h>
int isl_set_find_dim_by_id(__isl_keep isl_set *set,
        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);

#include <isl/map.h>
int isl_map_find_dim_by_id(__isl_keep isl_map *map,
        enum isl_dim_type type, __isl_keep isl_id *id);
int isl_basic_map_find_dim_by_name(
        __isl_keep isl_basic_map *bmap,
        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);
int isl_union_map_find_dim_by_name(
        __isl_keep isl_union_map *umap,
        enum isl_dim_type type, const char *name);

#include <isl/aff.h>
int isl_multi_aff_find_dim_by_id(
        __isl_keep isl_multi_aff *ma,
        enum isl_dim_type type, __isl_keep isl_id *id);
int isl_multi_pw_aff_find_dim_by_id(
        __isl_keep isl_multi_pw_aff *mpa,
        enum isl_dim_type type, __isl_keep isl_id *id);
int isl_multi_union_pw_aff_find_dim_by_id(
        __isl_keep isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type, __isl_keep isl_id *id);
int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff,
        enum isl_dim_type type, const char *name);
int isl_multi_aff_find_dim_by_name(
        __isl_keep isl_multi_aff *ma,
        enum isl_dim_type type, const char *name);
int isl_pw_aff_find_dim_by_name(__isl_keep isl_pw_aff *pa,
        enum isl_dim_type type, const char *name);
int isl_multi_pw_aff_find_dim_by_name(
        __isl_keep isl_multi_pw_aff *mpa,
        enum isl_dim_type type, const char *name);
int isl_pw_multi_aff_find_dim_by_name(
        __isl_keep isl_pw_multi_aff *pma,
        enum isl_dim_type type, const char *name);
int isl_union_pw_aff_find_dim_by_name(
        __isl_keep isl_union_pw_aff *upa,
        enum isl_dim_type type, const char *name);
int isl_union_pw_multi_aff_find_dim_by_name(
        __isl_keep isl_union_pw_multi_aff *upma,
        enum isl_dim_type type, const char *name);
int isl_multi_union_pw_aff_find_dim_by_name(
        __isl_keep isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type, const char *name);

#include <isl/polynomial.h>
int isl_pw_qpolynomial_find_dim_by_name(
        __isl_keep isl_pw_qpolynomial *pwqp,
        enum isl_dim_type type, const char *name);
int isl_pw_qpolynomial_fold_find_dim_by_name(
        __isl_keep isl_pw_qpolynomial_fold *pwf,
        enum isl_dim_type type, const char *name);
int isl_union_pw_qpolynomial_find_dim_by_name(
        __isl_keep isl_union_pw_qpolynomial *upwqp,
        enum isl_dim_type type, const char *name);
int isl_union_pw_qpolynomial_fold_find_dim_by_name(
        __isl_keep isl_union_pw_qpolynomial_fold *upwf,
        enum isl_dim_type type, const char *name);

The identifiers or names of entire spaces may be set or read off using the following functions.

#include <isl/space.h>
__isl_give isl_space *isl_space_set_domain_tuple_id(
        __isl_take isl_space *space,
        __isl_take isl_id *id);
__isl_give isl_space *isl_space_set_range_tuple_id(
        __isl_take isl_space *space,
        __isl_take isl_id *id);
__isl_give isl_space *isl_space_set_tuple_id(
        __isl_take isl_space *space,
        enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_space *isl_space_reset_tuple_id(
        __isl_take isl_space *space, enum isl_dim_type type);
isl_bool isl_space_has_domain_tuple_id(
        __isl_keep isl_space *space);
isl_bool isl_space_has_range_tuple_id(
        __isl_keep isl_space *space);
isl_bool isl_space_has_tuple_id(
        __isl_keep isl_space *space,
        enum isl_dim_type type);
__isl_give isl_id *isl_space_get_domain_tuple_id(
        __isl_keep isl_space *space);
__isl_give isl_id *isl_space_get_range_tuple_id(
        __isl_keep isl_space *space);
__isl_give isl_id *isl_space_get_tuple_id(
        __isl_keep isl_space *space, enum isl_dim_type type);
__isl_give isl_space *isl_space_set_tuple_name(
        __isl_take isl_space *space,
        enum isl_dim_type type, const char *s);
isl_bool isl_space_has_tuple_name(
        __isl_keep isl_space *space,
        enum isl_dim_type type);
__isl_keep const char *isl_space_get_tuple_name(
        __isl_keep isl_space *space,
        enum isl_dim_type type);

#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_set_tuple_id(
        __isl_take isl_local_space *ls,
        enum isl_dim_type type, __isl_take isl_id *id);

#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_set_tuple_id(
        __isl_take isl_basic_set *bset,
        __isl_take isl_id *id);
__isl_give isl_set *isl_set_set_tuple_id(
        __isl_take isl_set *set, __isl_take isl_id *id);
__isl_give isl_set *isl_set_reset_tuple_id(
        __isl_take isl_set *set);
isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set);
__isl_give isl_id *isl_set_get_tuple_id(
        __isl_keep isl_set *set);
__isl_give isl_basic_set *isl_basic_set_set_tuple_name(
        __isl_take isl_basic_set *set, const char *s);
__isl_give isl_set *isl_set_set_tuple_name(
        __isl_take isl_set *set, const char *s);
const char *isl_basic_set_get_tuple_name(
        __isl_keep isl_basic_set *bset);
isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set);
const char *isl_set_get_tuple_name(
        __isl_keep isl_set *set);

#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_set_tuple_id(
        __isl_take isl_basic_map *bmap,
        enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_map *isl_map_set_domain_tuple_id(
        __isl_take isl_map *map, __isl_take isl_id *id);
__isl_give isl_map *isl_map_set_range_tuple_id(
        __isl_take isl_map *map, __isl_take isl_id *id);
__isl_give isl_map *isl_map_set_tuple_id(
        __isl_take isl_map *map, enum isl_dim_type type,
        __isl_take isl_id *id);
__isl_give isl_map *isl_map_reset_tuple_id(
        __isl_take isl_map *map, enum isl_dim_type type);
isl_bool isl_map_has_domain_tuple_id(
        __isl_keep isl_map *map);
isl_bool isl_map_has_range_tuple_id(
        __isl_keep isl_map *map);
isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map,
        enum isl_dim_type type);
__isl_give isl_id *isl_map_get_domain_tuple_id(
        __isl_keep isl_map *map);
__isl_give isl_id *isl_map_get_range_tuple_id(
        __isl_keep isl_map *map);
__isl_give isl_id *isl_map_get_tuple_id(
        __isl_keep isl_map *map, enum isl_dim_type type);
__isl_give isl_map *isl_map_set_tuple_name(
        __isl_take isl_map *map,
        enum isl_dim_type type, const char *s);
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);
isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map,
        enum isl_dim_type type);
const char *isl_map_get_tuple_name(
        __isl_keep isl_map *map,
        enum isl_dim_type type);

#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_set_range_tuple_id(
        __isl_take isl_multi_val *mv,
        __isl_take isl_id *id);
__isl_give isl_multi_val *isl_multi_val_set_tuple_id(
        __isl_take isl_multi_val *mv,
        enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_multi_val *
isl_multi_val_reset_range_tuple_id(
        __isl_take isl_multi_val *mv);
__isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
        __isl_take isl_multi_val *mv,
        enum isl_dim_type type);
isl_bool isl_multi_val_has_range_tuple_id(
        __isl_keep isl_multi_val *mv);
__isl_give isl_id *isl_multi_val_get_range_tuple_id(
        __isl_keep isl_multi_val *mv);
isl_bool isl_multi_val_has_tuple_id(
        __isl_keep isl_multi_val *mv,
        enum isl_dim_type type);
__isl_give isl_id *isl_multi_val_get_tuple_id(
        __isl_keep isl_multi_val *mv,
        enum isl_dim_type type);
__isl_give isl_multi_val *isl_multi_val_set_tuple_name(
        __isl_take isl_multi_val *mv,
        enum isl_dim_type type, const char *s);
const char *isl_multi_val_get_tuple_name(
        __isl_keep isl_multi_val *mv,
        enum isl_dim_type type);

#include <isl/aff.h>
__isl_give isl_aff *isl_aff_set_tuple_id(
        __isl_take isl_aff *aff,
        enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_multi_aff *isl_multi_aff_set_range_tuple_id(
        __isl_take isl_multi_aff *ma,
        __isl_take isl_id *id);
__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_aff *isl_pw_aff_set_tuple_id(
        __isl_take isl_pw_aff *pwaff,
        enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_set_range_tuple_id(
        __isl_take isl_pw_multi_aff *pma,
        __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_pw_aff *
isl_multi_pw_aff_set_range_tuple_id(
        __isl_take isl_multi_pw_aff *mpa,
        __isl_take isl_id *id);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_range_tuple_id(
        __isl_take isl_multi_union_pw_aff *mupa,
        __isl_take isl_id *id);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_tuple_id(
        __isl_take isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_multi_aff *
isl_multi_aff_reset_range_tuple_id(
        __isl_take isl_multi_aff *ma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_reset_range_tuple_id(
        __isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_reset_range_tuple_id(
        __isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
        __isl_take isl_multi_aff *ma,
        enum isl_dim_type type);
__isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(
        __isl_take isl_pw_aff *pa,
        enum isl_dim_type type);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_reset_tuple_id(
        __isl_take isl_multi_pw_aff *mpa,
        enum isl_dim_type type);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_reset_tuple_id(
        __isl_take isl_pw_multi_aff *pma,
        enum isl_dim_type type);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_reset_tuple_id(
        __isl_take isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type);
isl_bool isl_multi_aff_has_range_tuple_id(
        __isl_keep isl_multi_aff *ma);
__isl_give isl_id *isl_multi_aff_get_range_tuple_id(
        __isl_keep isl_multi_aff *ma);
isl_bool isl_multi_aff_has_tuple_id(
        __isl_keep isl_multi_aff *ma,
        enum isl_dim_type type);
__isl_give isl_id *isl_multi_aff_get_tuple_id(
        __isl_keep isl_multi_aff *ma,
        enum isl_dim_type type);
isl_bool isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
        enum isl_dim_type type);
__isl_give isl_id *isl_pw_aff_get_tuple_id(
        __isl_keep isl_pw_aff *pa,
        enum isl_dim_type type);
isl_bool isl_pw_multi_aff_has_range_tuple_id(
        __isl_keep isl_pw_multi_aff *pma);
isl_bool isl_pw_multi_aff_has_tuple_id(
        __isl_keep isl_pw_multi_aff *pma,
        enum isl_dim_type type);
__isl_give isl_id *isl_pw_multi_aff_get_range_tuple_id(
        __isl_keep isl_pw_multi_aff *pma);
__isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
        __isl_keep isl_pw_multi_aff *pma,
        enum isl_dim_type type);
isl_bool isl_multi_pw_aff_has_range_tuple_id(
        __isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_id *isl_multi_pw_aff_get_range_tuple_id(
        __isl_keep isl_multi_pw_aff *mpa);
isl_bool isl_multi_pw_aff_has_tuple_id(
        __isl_keep isl_multi_pw_aff *mpa,
        enum isl_dim_type type);
__isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
        __isl_keep isl_multi_pw_aff *mpa,
        enum isl_dim_type type);
isl_bool isl_multi_union_pw_aff_has_range_tuple_id(
        __isl_keep isl_multi_union_pw_aff *mupa);
__isl_give isl_id *
isl_multi_union_pw_aff_get_range_tuple_id(
        __isl_keep isl_multi_union_pw_aff *mupa);
isl_bool isl_multi_union_pw_aff_has_tuple_id(
        __isl_keep isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type);
__isl_give isl_id *isl_multi_union_pw_aff_get_tuple_id(
        __isl_keep isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type);
__isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
        __isl_take isl_multi_aff *maff,
        enum isl_dim_type type, const char *s);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_set_tuple_name(
        __isl_take isl_multi_pw_aff *mpa,
        enum isl_dim_type type, const char *s);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_tuple_name(
        __isl_take isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type, const char *s);
const char *isl_multi_aff_get_tuple_name(
        __isl_keep isl_multi_aff *multi,
        enum isl_dim_type type);
isl_bool isl_pw_multi_aff_has_tuple_name(
        __isl_keep isl_pw_multi_aff *pma,
        enum isl_dim_type type);
const char *isl_pw_multi_aff_get_tuple_name(
        __isl_keep isl_pw_multi_aff *pma,
        enum isl_dim_type type);
const char *isl_multi_union_pw_aff_get_tuple_name(
        __isl_keep isl_multi_union_pw_aff *mupa,
        enum isl_dim_type type);

The type argument needs to be one of isl_dim_in, isl_dim_out or isl_dim_set. As with isl_space_get_name, the isl_space_get_tuple_name function returns a pointer to some internal data structure. Binary operations require the corresponding spaces of their arguments to have the same name.

To keep the names of all parameters and tuples, but reset the user pointers of all the corresponding identifiers, use the following function.

#include <isl/space.h>
__isl_give isl_space *isl_space_reset_user(
        __isl_take isl_space *space);

#include <isl/set.h>
__isl_give isl_set *isl_set_reset_user(
        __isl_take isl_set *set);

#include <isl/map.h>
__isl_give isl_map *isl_map_reset_user(
        __isl_take isl_map *map);

#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_reset_user(
        __isl_take isl_union_set *uset);

#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_reset_user(
        __isl_take isl_union_map *umap);

#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_reset_user(
        __isl_take isl_multi_id *mi);

#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_reset_user(
        __isl_take isl_multi_val *mv);

#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_reset_user(
        __isl_take isl_multi_aff *ma);
__isl_give isl_pw_aff *isl_pw_aff_reset_user(
        __isl_take isl_pw_aff *pa);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(
        __isl_take isl_multi_pw_aff *mpa);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_user(
        __isl_take isl_pw_multi_aff *pma);
__isl_give isl_union_pw_aff *isl_union_pw_aff_reset_user(
        __isl_take isl_union_pw_aff *upa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_reset_user(
        __isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_reset_user(
        __isl_take isl_union_pw_multi_aff *upma);

#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_reset_user(
        __isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_reset_user(
        __isl_take isl_union_pw_qpolynomial *upwqp);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_reset_user(
        __isl_take isl_pw_qpolynomial_fold *pwf);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_reset_user(
        __isl_take isl_union_pw_qpolynomial_fold *upwf);

Spaces can be nested. In particular, the domain of a set or the domain or range of a relation can be a nested relation. This process is also called wrapping. The functions for detecting, constructing and deconstructing such nested spaces can be found in the wrapping properties of "Unary Properties", the wrapping operations of "Unary Operations" and the Cartesian product operations of "Basic Operations".

Spaces can be created from other spaces using the functions described in "Unary Operations" and "Binary Operations".

Local Spaces

A local space is essentially a space with zero or more existentially quantified variables. The local space of various objects can be obtained using the following functions.

#include <isl/constraint.h>
__isl_give isl_local_space *isl_constraint_get_local_space(
        __isl_keep isl_constraint *constraint);

#include <isl/set.h>
__isl_give isl_local_space *isl_basic_set_get_local_space(
        __isl_keep isl_basic_set *bset);

#include <isl/map.h>
__isl_give isl_local_space *isl_basic_map_get_local_space(
        __isl_keep isl_basic_map *bmap);

#include <isl/aff.h>
__isl_give isl_local_space *isl_aff_get_domain_local_space(
        __isl_keep isl_aff *aff);
__isl_give isl_local_space *isl_aff_get_local_space(
        __isl_keep isl_aff *aff);

A new local space can be created from a space using

#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_from_space(
        __isl_take isl_space *space);

They can be inspected, modified, copied and freed using the following functions.

#include <isl/local_space.h>
isl_bool isl_local_space_is_params(
        __isl_keep isl_local_space *ls);
isl_bool isl_local_space_is_set(
        __isl_keep isl_local_space *ls);
__isl_give isl_space *isl_local_space_get_space(
        __isl_keep isl_local_space *ls);
__isl_give isl_aff *isl_local_space_get_div(
        __isl_keep isl_local_space *ls, int pos);
__isl_give isl_local_space *isl_local_space_copy(
        __isl_keep isl_local_space *ls);
__isl_null isl_local_space *isl_local_space_free(
        __isl_take isl_local_space *ls);

Note that isl_local_space_get_div can only be used on local spaces of sets.

Two local spaces can be compared using

isl_bool isl_local_space_is_equal(
        __isl_keep isl_local_space *ls1,
        __isl_keep isl_local_space *ls2);

Local spaces can be created from other local spaces using the functions described in "Unary Operations" and "Binary Operations".

Creating New Sets and Relations

isl has functions for creating some standard sets and relations.

A basic set or relation can be converted to a set or relation using the following functions.

__isl_give isl_set *isl_basic_set_to_set(
        __isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_from_basic_set(
        __isl_take isl_basic_set *bset);
__isl_give isl_map *isl_map_from_basic_map(
        __isl_take isl_basic_map *bmap);

isl_basic_set_to_set and isl_set_from_basic_set perform the same operation.

Sets and relations can be converted to union sets and relations using the following functions.

__isl_give isl_union_set *isl_union_set_from_basic_set(
        __isl_take isl_basic_set *bset);
__isl_give isl_union_map *isl_union_map_from_basic_map(
        __isl_take isl_basic_map *bmap);
__isl_give isl_union_set *isl_set_to_union_set(
        __isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_from_set(
        __isl_take isl_set *set);
__isl_give isl_union_map *isl_map_to_union_map(
        __isl_take isl_map *map);
__isl_give isl_union_map *isl_union_map_from_map(
        __isl_take isl_map *map);

isl_map_to_union_map and isl_union_map_from_map perform the same operation. Similarly for isl_set_to_union_set and isl_union_set_from_set.

The inverse conversions below can only be used if the input union set or relation is known to contain elements in exactly one space.

#include <isl/union_set.h>
isl_bool isl_union_set_isa_set(
        __isl_keep isl_union_set *uset);
__isl_give isl_set *isl_union_set_as_set(
        __isl_take isl_union_set *uset);
__isl_give isl_set *isl_set_from_union_set(
        __isl_take isl_union_set *uset);

#include <isl/union_map.h>
isl_bool isl_union_map_isa_map(
        __isl_keep isl_union_map *umap);
__isl_give isl_map *isl_union_map_as_map(
        __isl_take isl_union_map *umap);
__isl_give isl_map *isl_map_from_union_map(
        __isl_take isl_union_map *umap);

isl_union_map_as_map and isl_map_from_union_map perform the same operation. Similarly for isl_union_set_as_set and isl_set_from_union_set.

Sets and relations can be copied and freed again using the following functions.

__isl_give isl_basic_set *isl_basic_set_copy(
        __isl_keep isl_basic_set *bset);
__isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
__isl_give isl_union_set *isl_union_set_copy(
        __isl_keep isl_union_set *uset);
__isl_give isl_basic_map *isl_basic_map_copy(
        __isl_keep isl_basic_map *bmap);
__isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
__isl_give isl_union_map *isl_union_map_copy(
        __isl_keep isl_union_map *umap);
__isl_null isl_basic_set *isl_basic_set_free(
        __isl_take isl_basic_set *bset);
__isl_null isl_set *isl_set_free(__isl_take isl_set *set);
__isl_null isl_union_set *isl_union_set_free(
        __isl_take isl_union_set *uset);
__isl_null isl_basic_map *isl_basic_map_free(
        __isl_take isl_basic_map *bmap);
__isl_null isl_map *isl_map_free(__isl_take isl_map *map);
__isl_null isl_union_map *isl_union_map_free(
        __isl_take isl_union_map *umap);

Other sets and relations can be constructed by starting from a universe set or relation, adding equality and/or inequality constraints and then projecting out the existentially quantified variables, if any. Constraints can be constructed, manipulated and added to (or removed from) (basic) sets and relations using the following functions.

#include <isl/constraint.h>
__isl_give isl_constraint *isl_constraint_alloc_equality(
        __isl_take isl_local_space *ls);
__isl_give isl_constraint *isl_constraint_alloc_inequality(
        __isl_take isl_local_space *ls);
__isl_give isl_constraint *isl_constraint_set_constant_si(
        __isl_take isl_constraint *constraint, int v);
__isl_give isl_constraint *isl_constraint_set_constant_val(
        __isl_take isl_constraint *constraint,
        __isl_take isl_val *v);
__isl_give isl_constraint *isl_constraint_set_coefficient_si(
        __isl_take isl_constraint *constraint,
        enum isl_dim_type type, int pos, int v);
__isl_give isl_constraint *
isl_constraint_set_coefficient_val(
        __isl_take isl_constraint *constraint,
        enum isl_dim_type type, int pos,
        __isl_take isl_val *v);
__isl_give isl_basic_map *isl_basic_map_add_constraint(
        __isl_take isl_basic_map *bmap,
        __isl_take isl_constraint *constraint);
__isl_give isl_basic_set *isl_basic_set_add_constraint(
        __isl_take isl_basic_set *bset,
        __isl_take isl_constraint *constraint);
__isl_give isl_map *isl_map_add_constraint(
        __isl_take isl_map *map,
        __isl_take isl_constraint *constraint);
__isl_give isl_set *isl_set_add_constraint(
        __isl_take isl_set *set,
        __isl_take isl_constraint *constraint);

For example, to create a set containing the even integers between 10 and 42, you could use the following code.

isl_space *space;
isl_local_space *ls;
isl_constraint *c;
isl_basic_set *bset;

space = isl_space_set_alloc(ctx, 0, 2);
bset = isl_basic_set_universe(isl_space_copy(space));
ls = isl_local_space_from_space(space);

c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
bset = isl_basic_set_add_constraint(bset, c);

c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
c = isl_constraint_set_constant_si(c, -10);
c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
bset = isl_basic_set_add_constraint(bset, c);

c = isl_constraint_alloc_inequality(ls);
c = isl_constraint_set_constant_si(c, 42);
c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
bset = isl_basic_set_add_constraint(bset, c);

bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);

However, this is considered to be a fairly low-level approach. It is more appropriate to construct a (basic) set by means of affine expressions (defined below in "Functions"). For example, the same set could be constructed as follows.

isl_val *v, *two;
isl_space *space;
isl_multi_aff *ma;
isl_aff *var, *cst;
isl_basic_set *bset;

space = isl_space_unit(ctx);
space = isl_space_add_unnamed_tuple_ui(space, 1);
ma = isl_multi_aff_identity_on_domain_space(
        isl_space_copy(space));
var = isl_multi_aff_get_at(ma, 0);
v = isl_val_int_from_si(ctx, 10);
cst = isl_aff_val_on_domain_space(isl_space_copy(space), v);
bset = isl_aff_ge_basic_set(isl_aff_copy(var), cst);

v = isl_val_int_from_si(ctx, 42);
cst = isl_aff_val_on_domain_space(space, v);
bset = isl_basic_set_intersect(bset,
        isl_aff_le_basic_set(var, cst));

two = isl_val_int_from_si(ctx, 2);
ma = isl_multi_aff_scale_val(ma, isl_val_copy(two));
bset = isl_basic_set_preimage_multi_aff(bset,
        isl_multi_aff_copy(ma));
ma = isl_multi_aff_scale_down_val(ma, isl_val_copy(two));
ma = isl_multi_aff_scale_down_val(ma, two);
bset = isl_basic_set_preimage_multi_aff(bset, ma);

Alternatively, the set can be parsed from a string representation.

isl_basic_set *bset;
bset = isl_basic_set_read_from_str(ctx,
        "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");

A basic set or relation can also be constructed from two matrices describing the equalities and the inequalities.

__isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
        __isl_take isl_space *space,
        __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
        enum isl_dim_type c1,
        enum isl_dim_type c2, enum isl_dim_type c3,
        enum isl_dim_type c4);
__isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
        __isl_take isl_space *space,
        __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
        enum isl_dim_type c1,
        enum isl_dim_type c2, enum isl_dim_type c3,
        enum isl_dim_type c4, enum isl_dim_type c5);

The isl_dim_type arguments indicate the order in which different kinds of variables appear in the input matrices and should be a permutation of isl_dim_cst (the constant term), isl_dim_param, isl_dim_set and isl_dim_div for sets and of isl_dim_cst, isl_dim_param, isl_dim_in, isl_dim_out and isl_dim_div for relations.

A (basic or union) set or relation can also be constructed from a (union) (piecewise) (multiple) affine expression or a list of affine expressions (See "Functions"), provided these affine expressions do not involve any NaN.

#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_from_multi_aff(
        __isl_take isl_multi_aff *ma);
__isl_give isl_set *isl_multi_aff_as_set(
        __isl_take isl_multi_aff *ma);
__isl_give isl_set *isl_set_from_multi_aff(
        __isl_take isl_multi_aff *ma);

#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_from_aff(
        __isl_take isl_aff *aff);
__isl_give isl_map *isl_map_from_aff(
        __isl_take isl_aff *aff);
__isl_give isl_basic_map *isl_basic_map_from_aff_list(
        __isl_take isl_space *domain_space,
        __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_multi_aff_as_map(
        __isl_take isl_multi_aff *ma);
__isl_give isl_map *isl_map_from_multi_aff(
        __isl_take isl_multi_aff *maff)

#include <isl/aff.h>
__isl_give isl_set *isl_set_from_pw_aff(
        __isl_take isl_pw_aff *pwaff);
__isl_give isl_map *isl_pw_aff_as_map(
        __isl_take isl_pw_aff *pa);
__isl_give isl_map *isl_map_from_pw_aff(
        __isl_take isl_pw_aff *pwaff);
__isl_give isl_set *isl_pw_multi_aff_as_set(
        __isl_take isl_pw_multi_aff *pma);
__isl_give isl_set *isl_set_from_pw_multi_aff(
        __isl_take isl_pw_multi_aff *pma);
__isl_give isl_map *isl_pw_multi_aff_as_map(
        __isl_take isl_pw_multi_aff *pma);
__isl_give isl_map *isl_map_from_pw_multi_aff(
        __isl_take isl_pw_multi_aff *pma);
__isl_give isl_set *isl_multi_pw_aff_as_set(
        __isl_take isl_multi_pw_aff *mpa);
__isl_give isl_set *isl_set_from_multi_pw_aff(
        __isl_take isl_multi_pw_aff *mpa);
__isl_give isl_map *isl_multi_pw_aff_as_map(
        __isl_take isl_multi_pw_aff *mpa);
__isl_give isl_map *isl_map_from_multi_pw_aff(
        __isl_take isl_multi_pw_aff *mpa);
__isl_give isl_union_map *isl_union_map_from_union_pw_aff(
        __isl_take isl_union_pw_aff *upa);
__isl_give isl_union_map *
isl_union_pw_multi_aff_as_union_map(
        __isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_map *
isl_union_map_from_union_pw_multi_aff(
        __isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_map *
isl_union_map_from_multi_union_pw_aff(
        __isl_take isl_multi_union_pw_aff *mupa);

The domain_space argument describes the domain of the resulting basic relation. It is required because the list may consist of zero affine expressions. The mupa passed to isl_union_map_from_multi_union_pw_aff is not allowed to be zero-dimensional. The domain of the result is the shared domain of the union piecewise affine elements. isl_multi_aff_as_set and isl_set_from_multi_aff perform the same operation. Similarly for the pair isl_multi_aff_as_map and isl_map_from_multi_aff, for the pair isl_pw_aff_as_map and isl_map_from_pw_aff, for the pair isl_pw_multi_aff_as_set and isl_set_from_pw_multi_aff, for the pair isl_pw_multi_aff_as_map and isl_map_from_pw_multi_aff, the pair isl_multi_pw_aff_as_set and isl_set_from_multi_pw_aff, the pair isl_multi_pw_aff_as_map and isl_map_from_multi_pw_aff, and isl_union_pw_multi_aff_as_union_map and isl_union_map_from_union_pw_multi_aff.

Inspecting Sets and Relations

Usually, the user should not have to care about the actual constraints of the sets and maps, but should instead apply the abstract operations explained in the following sections. Occasionally, however, it may be required to inspect the individual coefficients of the constraints. This section explains how to do so. In these cases, it may also be useful to have isl compute an explicit representation of the existentially quantified variables.

__isl_give isl_set *isl_set_compute_divs(
        __isl_take isl_set *set);
__isl_give isl_map *isl_map_compute_divs(
        __isl_take isl_map *map);
__isl_give isl_union_set *isl_union_set_compute_divs(
        __isl_take isl_union_set *uset);
__isl_give isl_union_map *isl_union_map_compute_divs(
        __isl_take isl_union_map *umap);

This explicit representation defines the existentially quantified variables as integer divisions of the other variables, possibly including earlier existentially quantified variables. An explicitly represented existentially quantified variable therefore has a unique value when the values of the other variables are known.

Alternatively, the existentially quantified variables can be removed using the following functions, which compute an overapproximation.

#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_remove_divs(
        __isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_remove_divs(
        __isl_take isl_set *set);

#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_remove_divs(
        __isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_remove_divs(
        __isl_take isl_map *map);

#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_remove_divs(
        __isl_take isl_union_set *bset);

#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_remove_divs(
        __isl_take isl_union_map *bmap);

It is also possible to only remove those divs that are defined in terms of a given range of dimensions or only those for which no explicit representation is known.

__isl_give isl_basic_set *
isl_basic_set_remove_divs_involving_dims(
        __isl_take isl_basic_set *bset,
        enum isl_dim_type type,
        unsigned first, unsigned n);
__isl_give isl_basic_map *
isl_basic_map_remove_divs_involving_dims(
        __isl_take isl_basic_map *bmap,
        enum isl_dim_type type,
        unsigned first, unsigned n);
__isl_give isl_set *isl_set_remove_divs_involving_dims(
        __isl_take isl_set *set, enum isl_dim_type type,
        unsigned first, unsigned n);
__isl_give isl_map *isl_map_remove_divs_involving_dims(
        __isl_take isl_map *map, enum isl_dim_type type,
        unsigned first, unsigned n);

__isl_give isl_basic_set *
isl_basic_set_remove_unknown_divs(
        __isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_remove_unknown_divs(
        __isl_take isl_set *set);
__isl_give isl_map *isl_map_remove_unknown_divs(
        __isl_take isl_map *map);

To iterate over all the sets or maps in a union set or map, use

#include <isl/union_set.h>
isl_stat isl_union_set_foreach_set(
        __isl_keep isl_union_set *uset,
        isl_stat (*fn)(__isl_take isl_set *set, void *user),
        void *user);
isl_bool isl_union_set_every_set(
        __isl_keep isl_union_set *uset,
        isl_bool (*test)(__isl_keep isl_set *set,
                void *user),
        void *user);

#include <isl/union_map.h>
isl_stat isl_union_map_foreach_map(
        __isl_keep isl_union_map *umap,
        isl_stat (*fn)(__isl_take isl_map *map, void *user),
        void *user);
isl_bool isl_union_map_every_map(
        __isl_keep isl_union_map *umap,
        isl_bool (*test)(__isl_keep isl_map *map,
                void *user),
        void *user);

These functions call the callback function once for each (pair of) space(s) for which there are elements in the input. The argument to the callback contains all elements in the input with that (pair of) space(s). The isl_union_set_every_set and isl_union_map_every_map variants check whether each call to the callback returns true and stops checking as soon as one of these calls returns false.

The number of sets or maps in a union set or map can be obtained from

isl_size isl_union_set_n_set(__isl_keep isl_union_set *uset);
isl_size isl_union_map_n_map(__isl_keep isl_union_map *umap);

To extract the set or map in a given space from a union, use

__isl_give isl_set *isl_union_set_extract_set(
        __isl_keep isl_union_set *uset,
        __isl_take isl_space *space);
__isl_give isl_map *isl_union_map_extract_map(
        __isl_keep isl_union_map *umap,
        __isl_take isl_space *space);

To iterate over all the basic sets or maps in a set or map, use

isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,
        isl_stat (*fn)(__isl_take isl_basic_set *bset,
                void *user),
        void *user);
isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
        isl_stat (*fn)(__isl_take isl_basic_map *bmap,
                void *user),
        void *user);

The callback function fn should return isl_stat_ok if successful and isl_stat_error if an error occurs. In the latter case, or if any other error occurs, the above functions will return isl_stat_error.

It should be noted that isl does not guarantee that the basic sets or maps passed to fn are disjoint. If this is required, then the user should call one of the following functions first.

__isl_give isl_set *isl_set_make_disjoint(
        __isl_take isl_set *set);
__isl_give isl_map *isl_map_make_disjoint(
        __isl_take isl_map *map);

The number of basic sets in a set can be obtained or the number of basic maps in a map can be obtained from

#include <isl/set.h>
isl_size isl_set_n_basic_set(__isl_keep isl_set *set);

#include <isl/map.h>
isl_size isl_map_n_basic_map(__isl_keep isl_map *map);

It is also possible to obtain a list of (basic) sets from a set or union set, a list of basic maps from a map and a list of maps from a union map.

#include <isl/set.h>
__isl_give isl_basic_set_list *isl_set_get_basic_set_list(
        __isl_keep isl_set *set);

#include <isl/union_set.h>
__isl_give isl_basic_set_list *
isl_union_set_get_basic_set_list(
        __isl_keep isl_union_set *uset);
__isl_give isl_set_list *isl_union_set_get_set_list(
        __isl_keep isl_union_set *uset);

#include <isl/map.h>
__isl_give isl_basic_map_list *isl_map_get_basic_map_list(
        __isl_keep isl_map *map);

#include <isl/union_map.h>
__isl_give isl_map_list *isl_union_map_get_map_list(
        __isl_keep isl_union_map *umap);

The returned list can be manipulated using the functions in "Lists".

To iterate over the constraints of a basic set or map, use

#include <isl/constraint.h>

isl_size isl_basic_set_n_constraint(
        __isl_keep isl_basic_set *bset);
isl_stat isl_basic_set_foreach_constraint(
        __isl_keep isl_basic_set *bset,
        isl_stat (*fn)(__isl_take isl_constraint *c,
                void *user),
        void *user);
isl_size isl_basic_map_n_constraint(
        __isl_keep isl_basic_map *bmap);
isl_stat isl_basic_map_foreach_constraint(
        __isl_keep isl_basic_map *bmap,
        isl_stat (*fn)(__isl_take isl_constraint *c,
                void *user),
        void *user);
__isl_null isl_constraint *isl_constraint_free(
        __isl_take isl_constraint *c);

Again, the callback function fn should return isl_stat_ok if successful and isl_stat_error if an error occurs. In the latter case, or if any other error occurs, the above functions will return isl_stat_error. The constraint c represents either an equality or an inequality. Use the following function to find out whether a constraint represents an equality. If not, it represents an inequality.

isl_bool isl_constraint_is_equality(
        __isl_keep isl_constraint *constraint);

It is also possible to obtain a list of constraints from a basic map or set

#include <isl/constraint.h>
__isl_give isl_constraint_list *
isl_basic_map_get_constraint_list(
        __isl_keep isl_basic_map *bmap);
__isl_give isl_constraint_list *
isl_basic_set_get_constraint_list(
        __isl_keep isl_basic_set *bset);

These functions require that all existentially quantified variables have an explicit representation. The returned list can be manipulated using the functions in "Lists".

The coefficients of the constraints can be inspected using the following functions.

isl_bool isl_constraint_is_lower_bound(
        __isl_keep isl_constraint *constraint,
        enum isl_dim_type type, unsigned pos);
isl_bool isl_constraint_is_upper_bound(
        __isl_keep isl_constraint *constraint,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_val *isl_constraint_get_constant_val(
        __isl_keep isl_constraint *constraint);
__isl_give isl_val *isl_constraint_get_coefficient_val(
        __isl_keep isl_constraint *constraint,
        enum isl_dim_type type, int pos);

The explicit representations of the existentially quantified variables can be inspected using the following function. Note that the user is only allowed to use this function if the inspected set or map is the result of a call to isl_set_compute_divs or isl_map_compute_divs. The existentially quantified variable is equal to the floor of the returned affine expression. The affine expression itself can be inspected using the functions in "Functions".

__isl_give isl_aff *isl_constraint_get_div(
        __isl_keep isl_constraint *constraint, int pos);

To obtain the constraints of a basic set or map in matrix form, use the following functions.

__isl_give isl_mat *isl_basic_set_equalities_matrix(
        __isl_keep isl_basic_set *bset,
        enum isl_dim_type c1, enum isl_dim_type c2,
        enum isl_dim_type c3, enum isl_dim_type c4);
__isl_give isl_mat *isl_basic_set_inequalities_matrix(
        __isl_keep isl_basic_set *bset,
        enum isl_dim_type c1, enum isl_dim_type c2,
        enum isl_dim_type c3, enum isl_dim_type c4);
__isl_give isl_mat *isl_basic_map_equalities_matrix(
        __isl_keep isl_basic_map *bmap,
        enum isl_dim_type c1,
        enum isl_dim_type c2, enum isl_dim_type c3,
        enum isl_dim_type c4, enum isl_dim_type c5);
__isl_give isl_mat *isl_basic_map_inequalities_matrix(
        __isl_keep isl_basic_map *bmap,
        enum isl_dim_type c1,
        enum isl_dim_type c2, enum isl_dim_type c3,
        enum isl_dim_type c4, enum isl_dim_type c5);

The isl_dim_type arguments dictate the order in which different kinds of variables appear in the resulting matrix. For set inputs, they should be a permutation of isl_dim_cst (the constant term), isl_dim_param, isl_dim_set and isl_dim_div. For map inputs, they should be a permutation of isl_dim_cst, isl_dim_param, isl_dim_in, isl_dim_out and isl_dim_div.

Points

Points are elements of a set. They can be used to construct simple sets (boxes) or they can be used to represent the individual elements of a set. The zero point (the origin) can be created using

__isl_give isl_point *isl_point_zero(__isl_take isl_space *space);

The coordinates of a point can be inspected, set and changed using

#include <isl/point.h>
__isl_give isl_multi_val *isl_point_get_multi_val(
        __isl_keep isl_point *pnt);
__isl_give isl_val *isl_point_get_coordinate_val(
        __isl_keep isl_point *pnt,
        enum isl_dim_type type, int pos);
__isl_give isl_point *isl_point_set_coordinate_val(
        __isl_take isl_point *pnt,
        enum isl_dim_type type, int pos,
        __isl_take isl_val *v);

__isl_give isl_point *isl_point_add_ui(
        __isl_take isl_point *pnt,
        enum isl_dim_type type, int pos, unsigned val);
__isl_give isl_point *isl_point_sub_ui(
        __isl_take isl_point *pnt,
        enum isl_dim_type type, int pos, unsigned val);

Points can be copied or freed using

__isl_give isl_point *isl_point_copy(
        __isl_keep isl_point *pnt);
__isl_null isl_point *isl_point_free(
        __isl_take isl_point *pnt);

A singleton set can be created from a point using the following functions.

__isl_give isl_basic_set *isl_basic_set_from_point(
        __isl_take isl_point *pnt);
__isl_give isl_set *isl_point_to_set(
        __isl_take isl_point *pnt);
__isl_give isl_set *isl_set_from_point(
        __isl_take isl_point *pnt);
__isl_give isl_union_set *isl_union_set_from_point(
        __isl_take isl_point *pnt);

isl_point_to_set and isl_set_from_point perform the same operation.

A box can be created from two opposite extremal points using

__isl_give isl_basic_set *isl_basic_set_box_from_points(
        __isl_take isl_point *pnt1,
        __isl_take isl_point *pnt2);
__isl_give isl_set *isl_set_box_from_points(
        __isl_take isl_point *pnt1,
        __isl_take isl_point *pnt2);

All elements of a bounded (union) set can be enumerated using the following functions.

isl_stat isl_set_foreach_point(__isl_keep isl_set *set,
        isl_stat (*fn)(__isl_take isl_point *pnt,
                void *user),
        void *user);
isl_stat isl_union_set_foreach_point(
        __isl_keep isl_union_set *uset,
        isl_stat (*fn)(__isl_take isl_point *pnt,
                void *user),
        void *user);

The function fn is called for each integer point in set with as second argument the last argument of the isl_set_foreach_point call. The function fn should return isl_stat_ok on success and isl_stat_error on failure. In the latter case, isl_set_foreach_point will stop enumerating and return isl_stat_error as well. If the enumeration is performed successfully and to completion, then isl_set_foreach_point returns isl_stat_ok.

To obtain a single point of a (basic or union) set, use

__isl_give isl_point *isl_basic_set_sample_point(
        __isl_take isl_basic_set *bset);
__isl_give isl_point *isl_set_sample_point(
        __isl_take isl_set *set);
__isl_give isl_point *isl_union_set_sample_point(
        __isl_take isl_union_set *uset);

If set does not contain any (integer) points, then the resulting point will be ``void'', a property that can be tested using

isl_bool isl_point_is_void(__isl_keep isl_point *pnt);

Functions

Besides sets and relation, isl also supports various types of functions. Each of these types is derived from the value type (see "Values") or from one of two primitive function types through the application of zero or more type constructors. As a special case, a multiple expression can also be derived from an identifier (see "Identifiers") although the result is not really a function. We first describe the primitive type and then we describe the types derived from these primitive types.

Primitive Functions

isl support two primitive function types, quasi-affine expressions and quasipolynomials. A quasi-affine expression is defined either over a parameter space or over a set and is composed of integer constants, parameters and set variables, addition, subtraction and integer division by an integer constant. For example, the quasi-affine expression

[n] -> { [x] -> [2*floor((4 n + x)/9)] }

maps x to 2*floor((4 n + x)/9. A quasipolynomial is a polynomial expression in quasi-affine expression. That is, it additionally allows for multiplication. Note, though, that it is not allowed to construct an integer division of an expression involving multiplications. Here is an example of a quasipolynomial that is not quasi-affine expression

[n] -> { [x] -> (n*floor((4 n + x)/9)) }

Note that the external representations of quasi-affine expressions and quasipolynomials are different. Quasi-affine expressions use a notation with square brackets just like binary relations, while quasipolynomials do not. This might change at some point.

If a primitive function is defined over a parameter space, then the space of the function itself is that of a set. If it is defined over a set, then the space of the function is that of a relation. In both cases, the set space (or the output space) is single-dimensional, anonymous and unstructured. To create functions with multiple dimensions or with other kinds of set or output spaces, use multiple expressions (see "Multiple Expressions").

Reductions

A reduction represents a maximum or a minimum of its base expressions. The only reduction type defined by isl is isl_qpolynomial_fold.

There are currently no functions to directly create such objects, but they do appear in the piecewise quasipolynomial reductions returned by the isl_pw_qpolynomial_bound function. See "Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions".

Reductions can be copied and freed using the following functions.

#include <isl/polynomial.h>
__isl_give isl_qpolynomial_fold *
isl_qpolynomial_fold_copy(
        __isl_keep isl_qpolynomial_fold *fold);
__isl_null isl_qpolynomial_fold *
isl_qpolynomial_fold_free(
        __isl_take isl_qpolynomial_fold *fold);

The type of a (union piecewise) reduction can be obtained using the following functions.

#include <isl/polynomial.h>
enum isl_fold isl_qpolynomial_fold_get_type(
        __isl_keep isl_qpolynomial_fold *fold);
enum isl_fold isl_pw_qpolynomial_fold_get_type(
        __isl_keep isl_pw_qpolynomial_fold *pwf);
enum isl_fold isl_union_pw_qpolynomial_fold_get_type(
        __isl_keep isl_union_pw_qpolynomial_fold *upwf);

The type may be either isl_fold_min or isl_fold_max (or isl_fold_error in case of error).

To iterate over all quasipolynomials in a reduction, use

isl_stat isl_qpolynomial_fold_foreach_qpolynomial(
        __isl_keep isl_qpolynomial_fold *fold,
        isl_stat (*fn)(__isl_take isl_qpolynomial *qp,
                  void *user), void *user);

Multiple Expressions

A multiple expression represents a sequence of zero or more base expressions, all defined on the same domain space. The domain space of the multiple expression is the same as that of the base expressions, but the range space can be any space. In case the base expressions have a set space, the corresponding multiple expression also has a set space. Objects of the value or identifier type do not have an associated space. The space of a multiple value or multiple identifier is therefore always a set space. Similarly, the space of a multiple union piecewise affine expression is always a set space. If the base expressions are not total, then a corresponding zero-dimensional multiple expression may have an explicit domain that keeps track of the domain outside of any base expressions.

The multiple expression types defined by isl are isl_multi_val, isl_multi_id, isl_multi_aff, isl_multi_pw_aff, isl_multi_union_pw_aff.

A multiple expression with the value zero for each output (or set) dimension can be created using the following functions.

#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_zero(
        __isl_take isl_space *space);
__isl_give isl_multi_val *isl_space_zero_multi_val(
        __isl_take isl_space *space);

#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_zero(
        __isl_take isl_space *space);
__isl_give isl_multi_aff *isl_space_zero_multi_aff(
        __isl_take isl_space *space);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
        __isl_take isl_space *space);
__isl_give isl_multi_pw_aff *isl_space_zero_multi_pw_aff(
        __isl_take isl_space *space);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_zero(
        __isl_take isl_space *space);
__isl_give isl_multi_union_pw_aff *
isl_space_zero_multi_union_pw_aff(
        __isl_take isl_space *space);

Since there is no canonical way of representing a zero value of type isl_union_pw_aff, the space passed to isl_multi_union_pw_aff_zero needs to be zero-dimensional. isl_multi_val_zero and isl_space_zero_multi_val perform the same operation. Similarly for the pair isl_multi_aff_zero and isl_space_zero_multi_aff, for the pair isl_multi_pw_aff_zero and isl_space_zero_multi_pw_aff and for the pair isl_multi_union_pw_aff_zero and isl_space_zero_multi_union_pw_aff.

An identity function can be created using the following functions. For the first group of functions, the space needs to be that of a set. For the second group, the space needs to be that of a relation with the same number of input and output dimensions. For the third group, the input function needs to live in a space with the same number of input and output dimensions and the identity function is created in that space.

#include <isl/aff.h>
__isl_give isl_multi_aff *
isl_multi_aff_identity_on_domain_space(
        __isl_take isl_space *space);
__isl_give isl_multi_aff *
isl_space_identity_multi_aff_on_domain(
        __isl_take isl_space *space);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_identity_on_domain_space(
        __isl_take isl_space *space);
__isl_give isl_multi_pw_aff *
isl_space_identity_multi_pw_aff_on_domain(
        __isl_take isl_space *space);
__isl_give isl_multi_aff *isl_multi_aff_identity(
        __isl_take isl_space *space);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
        __isl_take isl_space *space);
__isl_give isl_multi_aff *
isl_multi_aff_identity_multi_aff(
        __isl_take isl_multi_aff *ma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_identity_multi_pw_aff(
        __isl_take isl_multi_pw_aff *mpa);

isl_multi_aff_identity_on_domain_space and isl_space_identity_multi_aff_on_domain perform the same operation. Similarly for the pair isl_multi_pw_aff_identity_on_domain_space and isl_space_identity_multi_pw_aff_on_domain.

A function that performs a projection on a universe relation or set can be created using the following functions. See also the corresponding projection operations in "Unary Operations".

#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_domain_map(
        __isl_take isl_space *space);
__isl_give isl_multi_aff *isl_space_domain_map_multi_aff(
        __isl_take isl_space *space);
__isl_give isl_multi_aff *isl_multi_aff_range_map(
        __isl_take isl_space *space);
__isl_give isl_multi_aff *isl_space_range_map_multi_aff(
        __isl_take isl_space *space);
__isl_give isl_multi_aff *isl_multi_aff_project_out_map(
        __isl_take isl_space *space,
        enum isl_dim_type type,
        unsigned first, unsigned n);

isl_multi_aff_domain_map and isl_space_domain_map_multi_aff perform the same operation. Similarly for the pair isl_multi_aff_range_map and isl_space_range_map_multi_aff.

A multiple expression can be created from a single base expression using the following functions. The space of the created multiple expression is the same as that of the base expression, except for isl_multi_union_pw_aff_from_union_pw_aff where the input lives in a parameter space and the output lives in a single-dimensional set space.

#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_from_aff(
        __isl_take isl_aff *aff);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
        __isl_take isl_pw_aff *pa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_union_pw_aff(
        __isl_take isl_union_pw_aff *upa);

A multiple expression can be created from a list of base expression in a specified space. The domain of this space needs to be the same as the domains of the base expressions in the list. If the base expressions have a set space (or no associated space), then this space also needs to be a set space.

#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_from_id_list(
        __isl_take isl_space *space,
        __isl_take isl_id_list *list);
__isl_give isl_multi_id *isl_space_multi_id(
        __isl_take isl_space *space,
        __isl_take isl_id_list *list);

#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_from_val_list(
        __isl_take isl_space *space,
        __isl_take isl_val_list *list);
__isl_give isl_multi_val *isl_space_multi_val(
        __isl_take isl_space *space,
        __isl_take isl_val_list *list);

#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
        __isl_take isl_space *space,
        __isl_take isl_aff_list *list);
__isl_give isl_multi_aff *isl_space_multi_aff(
        __isl_take isl_space *space,
        __isl_take isl_aff_list *list);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_from_pw_aff_list(
        __isl_take isl_space *space,
        __isl_take isl_pw_aff_list *list);
__isl_give isl_multi_pw_aff *
isl_space_multi_pw_aff(
        __isl_take isl_space *space,
        __isl_take isl_pw_aff_list *list);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_union_pw_aff_list(
        __isl_take isl_space *space,
        __isl_take isl_union_pw_aff_list *list);
__isl_give isl_multi_union_pw_aff *
isl_space_multi_union_pw_aff(
        __isl_take isl_space *space,
        __isl_take isl_union_pw_aff_list *list);

isl_multi_id_from_id_list and isl_space_multi_id perform the same operation. Similarly for the pair isl_multi_val_from_val_list and isl_space_multi_val, for the pair isl_multi_aff_from_aff_list and isl_space_multi_aff, for the pair isl_multi_pw_aff_from_pw_aff_list and isl_space_multi_pw_aff and for the pair isl_multi_union_pw_aff_from_union_pw_aff_list and isl_space_multi_union_pw_aff.

As a convenience, a multiple piecewise expression can also be created from a multiple expression, or even directly from a single base expression. Each piecewise expression in the result has a single universe cell.

#include <isl/aff.h>
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_aff(
        __isl_take isl_aff *aff);
__isl_give isl_multi_pw_aff *
isl_multi_aff_to_multi_pw_aff(
        __isl_take isl_multi_aff *ma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_from_multi_aff(
        __isl_take isl_multi_aff *ma);

isl_multi_aff_to_multi_pw_aff and isl_multi_pw_aff_from_multi_aff perform the same operation.

Similarly, a multiple union expression can be created from a multiple expression.

#include <isl/aff.h>
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_multi_aff(
        __isl_take isl_multi_aff *ma);
__isl_give isl_multi_union_pw_aff *
isl_multi_aff_to_multi_union_pw_aff(
        __isl_take isl_multi_aff *ma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_multi_pw_aff(
        __isl_take isl_multi_pw_aff *mpa);

isl_multi_aff_to_multi_union_pw_aff and isl_multi_union_pw_aff_from_multi_aff perform the same operation.

A multiple quasi-affine expression can be created from a multiple value with a given domain space using the following function.

#include <isl/aff.h>
__isl_give isl_multi_aff *
isl_multi_aff_multi_val_on_domain_space(
        __isl_take isl_space *space,
        __isl_take isl_multi_val *mv);
__isl_give isl_multi_aff *
isl_space_multi_aff_on_domain_multi_val(
        __isl_take isl_space *space,
        __isl_take isl_multi_val *mv);
__isl_give isl_multi_aff *
isl_multi_aff_multi_val_on_space(
        __isl_take isl_space *space,
        __isl_take isl_multi_val *mv);

isl_space_multi_aff_on_domain_multi_val and isl_multi_aff_multi_val_on_space are alternative names for isl_multi_aff_multi_val_on_domain_space.

Similarly, a multiple union piecewise affine expression can be created from a multiple value with a given domain or a (piecewise) multiple affine expression with a given domain using the following functions.

#include <isl/aff.h>
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_multi_val_on_domain(
        __isl_take isl_union_set *domain,
        __isl_take isl_multi_val *mv);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_multi_aff_on_domain(
        __isl_take isl_union_set *domain,
        __isl_take isl_multi_aff *ma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_pw_multi_aff_on_domain(
        __isl_take isl_union_set *domain,
        __isl_take isl_pw_multi_aff *pma);

Multiple expressions can be copied and freed using the following functions.

#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_copy(
        __isl_keep isl_multi_id *mi);
__isl_null isl_multi_id *isl_multi_id_free(
        __isl_take isl_multi_id *mi);

#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_copy(
        __isl_keep isl_multi_val *mv);
__isl_null isl_multi_val *isl_multi_val_free(
        __isl_take isl_multi_val *mv);

#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_copy(
        __isl_keep isl_multi_aff *maff);
__isl_null isl_multi_aff *isl_multi_aff_free(
        __isl_take isl_multi_aff *maff);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
        __isl_keep isl_multi_pw_aff *mpa);
__isl_null isl_multi_pw_aff *isl_multi_pw_aff_free(
        __isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_copy(
        __isl_keep isl_multi_union_pw_aff *mupa);
__isl_null isl_multi_union_pw_aff *
isl_multi_union_pw_aff_free(
        __isl_take isl_multi_union_pw_aff *mupa);

The number of base expressions in a multiple expression can be obtained using the following functions.

#include <isl/id.h>
int isl_multi_id_size(__isl_keep isl_multi_id *mi);

#include <isl/val.h>
isl_size isl_multi_val_size(__isl_keep isl_multi_val *mv);

#include <isl/aff.h>
isl_size isl_multi_aff_size(
        __isl_keep isl_multi_aff *multi);
isl_size isl_multi_pw_aff_size(
        __isl_keep isl_multi_pw_aff *mpa);
isl_size isl_multi_union_pw_aff_size(
        __isl_keep isl_multi_union_pw_aff *mupa);

The base expression at a given position of a multiple expression can be extracted using the following functions.

#include <isl/id.h>
__isl_give isl_id *isl_multi_id_get_at(
        __isl_keep isl_multi_id *mi, int pos);
__isl_give isl_id *isl_multi_id_get_id(
        __isl_keep isl_multi_id *mi, int pos);

#include <isl/val.h>
__isl_give isl_val *isl_multi_val_get_at(
        __isl_keep isl_multi_val *mv, int pos);
__isl_give isl_val *isl_multi_val_get_val(
        __isl_keep isl_multi_val *mv, int pos);

#include <isl/aff.h>
__isl_give isl_aff *isl_multi_aff_get_at(
        __isl_keep isl_multi_aff *ma, int pos);
__isl_give isl_aff *isl_multi_aff_get_aff(
        __isl_keep isl_multi_aff *multi, int pos);
__isl_give isl_pw_aff *isl_multi_pw_aff_get_at(
        __isl_keep isl_multi_pw_aff *mpa, int pos);
__isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
        __isl_keep isl_multi_pw_aff *mpa, int pos);
__isl_give isl_union_pw_aff *
isl_multi_union_pw_aff_get_at(
        __isl_keep isl_multi_union_pw_aff *mupa, int pos);
__isl_give isl_union_pw_aff *
isl_multi_union_pw_aff_get_union_pw_aff(
        __isl_keep isl_multi_union_pw_aff *mupa, int pos);

isl_multi_id_get_id is an alternative name for isl_multi_id_get_at. Similarly for the other pairs of functions.

The base expression can be replaced using the following functions.

#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_set_at(
        __isl_take isl_multi_id *mi, int pos,
        __isl_take isl_id *id);
__isl_give isl_multi_id *isl_multi_id_set_id(
        __isl_take isl_multi_id *mi, int pos,
        __isl_take isl_id *id);

#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_set_at(
        __isl_take isl_multi_val *mv, int pos,
        __isl_take isl_val *val);
__isl_give isl_multi_val *isl_multi_val_set_val(
        __isl_take isl_multi_val *mv, int pos,
        __isl_take isl_val *val);

#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_set_at(
        __isl_take isl_multi_aff *ma, int pos,
        __isl_take isl_aff *aff);
__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_pw_aff *isl_multi_pw_aff_set_at(
        __isl_take isl_multi_pw_aff *mpa, int pos,
        __isl_take isl_pw_aff *pa);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_set_pw_aff(
        __isl_take isl_multi_pw_aff *mpa, int pos,
        __isl_take isl_pw_aff *pa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_at(
        __isl_take isl_multi_union_pw_aff *mupa, int pos,
        __isl_take isl_union_pw_aff *upa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_union_pw_aff(
        __isl_take isl_multi_union_pw_aff *mupa, int pos,
        __isl_take isl_union_pw_aff *upa);

isl_multi_id_set_id is an alternative name for isl_multi_id_set_at. Similarly for the other pairs of functions.

A list of all base expressions of a multiple expression can be extracted using the following functions.

#include <isl/id.h>
__isl_give isl_id_list *isl_multi_id_get_list(
        __isl_keep isl_multi_id *mi);

#include <isl/val.h>
__isl_give isl_val_list *isl_multi_val_get_list(
        __isl_keep isl_multi_val *mv);

#include <isl/aff.h>
__isl_give isl_aff_list *isl_multi_aff_get_list(
        __isl_keep isl_multi_aff *multi);
__isl_give isl_pw_aff_list *isl_multi_pw_aff_get_list(
        __isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_union_pw_aff_list *
isl_multi_union_pw_aff_list(
        __isl_keep isl_multi_union_pw_aff *mupa);

The constant terms of the base expressions can be obtained using the following function.

#include <isl/aff.h>
__isl_give isl_multi_val *
isl_multi_aff_get_constant_multi_val(
        __isl_keep isl_multi_aff *ma);

As a convenience, a sequence of base expressions that have their domains in a given space can be extracted from a sequence of union expressions using the following function.

#include <isl/aff.h>
__isl_give isl_multi_pw_aff *
isl_multi_union_pw_aff_extract_multi_pw_aff(
        __isl_keep isl_multi_union_pw_aff *mupa,
        __isl_take isl_space *space);

Note that there is a difference between isl_multi_union_pw_aff and isl_union_pw_multi_aff objects. The first is a sequence of unions of piecewise expressions, while the second is a union of piecewise sequences. In particular, multiple affine expressions in an isl_union_pw_multi_aff may live in different spaces, while there is only a single multiple expression in an isl_multi_union_pw_aff, which can therefore only live in a single space. This means that not every isl_union_pw_multi_aff can be converted to an isl_multi_union_pw_aff. Conversely, the elements of an isl_multi_union_pw_aff may be defined over different domains, while each multiple expression inside an isl_union_pw_multi_aff has a single domain. The conversion of an isl_union_pw_multi_aff of dimension greater than one may therefore not be exact. The following functions can be used to perform these conversions when they are possible.

#include <isl/aff.h>
__isl_give isl_multi_union_pw_aff *
isl_union_pw_multi_aff_as_multi_union_pw_aff(
        __isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_union_pw_multi_aff(
        __isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_multi_union_pw_aff(
        __isl_take isl_multi_union_pw_aff *mupa);

isl_union_pw_multi_aff_as_multi_union_pw_aff and isl_multi_union_pw_aff_from_union_pw_multi_aff perform the same operation.

Piecewise Expressions

A piecewise expression is an expression that is described using zero or more base expression defined over the same number of cells in the domain space of the base expressions. All base expressions are defined over the same domain space and the cells are disjoint. The space of a piecewise expression is the same as that of the base expressions. If the union of the cells is a strict subset of the domain space, then the value of the piecewise expression outside this union is different for types derived from quasi-affine expressions and those derived from quasipolynomials. Piecewise expressions derived from quasi-affine expressions are considered to be undefined outside the union of their cells. Piecewise expressions derived from quasipolynomials are considered to be zero outside the union of their cells.

Piecewise quasipolynomials are mainly used by the barvinok library for representing the number of elements in a parametric set or map. For example, the piecewise quasipolynomial

[n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }

represents the number of points in the map

[n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }

The piecewise expression types defined by isl are isl_pw_aff, isl_pw_multi_aff, isl_pw_qpolynomial and isl_pw_qpolynomial_fold.

A piecewise expression with no cells can be created using the following functions.

#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_empty(
        __isl_take isl_space *space);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
        __isl_take isl_space *space);

A piecewise expression with a single universe cell can be created using the following functions.

#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_from_aff(
        __isl_take isl_aff *aff);
__isl_give isl_pw_multi_aff *
isl_multi_aff_to_pw_multi_aff(
        __isl_take isl_multi_aff *ma);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_from_multi_aff(
        __isl_take isl_multi_aff *ma);

#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_from_qpolynomial(
        __isl_take isl_qpolynomial *qp);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_from_qpolynomial_fold(
        __isl_take isl_qpolynomial_fold *fold);

isl_multi_aff_to_pw_multi_aff and isl_pw_multi_aff_from_multi_aff perform the same operation.

The inverse conversions below can only be used if the input expression is known to be defined over a single universe domain.

#include <isl/aff.h>
isl_bool isl_pw_aff_isa_aff(__isl_keep isl_pw_aff *pa);
__isl_give isl_aff *isl_pw_aff_as_aff(
        __isl_take isl_pw_aff *pa);
isl_bool isl_multi_pw_aff_isa_multi_aff(
        __isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_multi_aff *isl_multi_pw_aff_as_multi_aff(
        __isl_take isl_multi_pw_aff *mpa);
isl_bool isl_pw_multi_aff_isa_multi_aff(
        __isl_keep isl_pw_multi_aff *pma);
__isl_give isl_multi_aff *isl_pw_multi_aff_as_multi_aff(
        __isl_take isl_pw_multi_aff *pma);

#include <isl/polynomial.h>
isl_bool isl_pw_qpolynomial_isa_qpolynomial(
        __isl_keep isl_pw_qpolynomial *pwqp);
__isl_give isl_qpolynomial *
isl_pw_qpolynomial_as_qpolynomial(
        __isl_take isl_pw_qpolynomial *pwqp);
isl_bool isl_pw_qpolynomial_fold_isa_qpolynomial_fold(
        __isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_give isl_qpolynomial_fold *
isl_pw_qpolynomial_fold_as_qpolynomial_fold(
        __isl_take isl_pw_qpolynomial_fold *pwf);

A piecewise expression with a single specified cell can be created using the following functions.

#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_alloc(
        __isl_take isl_set *set, __isl_take isl_aff *aff);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
        __isl_take isl_set *set,
        __isl_take isl_multi_aff *maff);

#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
        __isl_take isl_set *set,
        __isl_take isl_qpolynomial *qp);

The following convenience functions first create a base expression and then create a piecewise expression over a universe domain.

#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
        __isl_take isl_local_space *ls);
__isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
        __isl_take isl_local_space *ls,
        enum isl_dim_type type, unsigned pos);
__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain_space(
        __isl_take isl_space *space);
__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(
        __isl_take isl_local_space *ls);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(
        __isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_identity_on_domain_space(
        __isl_take isl_space *space)
__isl_give isl_pw_multi_aff *
isl_space_identity_pw_multi_aff_on_domain(
        __isl_take isl_space *space)
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
        __isl_take isl_space *space);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_domain_map(
        __isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_space_domain_map_pw_multi_aff(
        __isl_take isl_space *space);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
        __isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_space_range_map_pw_multi_aff(
        __isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_project_out_map(
        __isl_take isl_space *space,
        enum isl_dim_type type,
        unsigned first, unsigned n);

#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
        __isl_take isl_space *space);

isl_pw_multi_aff_identity_on_domain_space and isl_space_identity_pw_multi_aff_on_domain perform the same operation. Similarly for the pair isl_pw_multi_aff_domain_map and isl_space_domain_map_pw_multi_aff and for the pair isl_pw_multi_aff_range_map and isl_space_range_map_pw_multi_aff.

The following convenience functions first create a base expression and then create a piecewise expression over a given domain.

#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_val_on_domain(
        __isl_take isl_set *domain,
        __isl_take isl_val *v);
__isl_give isl_pw_aff *isl_set_pw_aff_on_domain_val(
        __isl_take isl_set *domain,
        __isl_take isl_val *v);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_multi_val_on_domain(
        __isl_take isl_set *domain,
        __isl_take isl_multi_val *mv);
__isl_give isl_pw_multi_aff *
isl_set_pw_multi_aff_on_domain_multi_val(
        __isl_take isl_set *domain,
        __isl_take isl_multi_val *mv);
__isl_give isl_pw_aff *isl_pw_aff_param_on_domain_id(
        __isl_take isl_set *domain,
        __isl_take isl_id *id);
__isl_give isl_pw_aff *isl_set_param_pw_aff_on_domain_id(
        __isl_take isl_set *domain,
        __isl_take isl_id *id);

isl_set_pw_aff_on_domain_val is an alternative name for isl_pw_aff_val_on_domain. Similarly for the pair isl_set_pw_multi_aff_on_domain_multi_val and isl_pw_multi_aff_multi_val_on_domain and for the pair isl_set_param_pw_aff_on_domain_id and isl_pw_aff_param_on_domain_id.

As a convenience, a piecewise multiple expression can also be created from a piecewise expression. Each multiple expression in the result is derived from the corresponding base expression.

#include <isl/aff.h>
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
        __isl_take isl_pw_aff *pa);

Similarly, a piecewise quasipolynomial can be created from a piecewise quasi-affine expression using the following function.

#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_from_pw_aff(
        __isl_take isl_pw_aff *pwaff);

Piecewise expressions can be copied and freed using the following functions.

#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_copy(
        __isl_keep isl_pw_aff *pwaff);
__isl_null isl_pw_aff *isl_pw_aff_free(
        __isl_take isl_pw_aff *pwaff);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
        __isl_keep isl_pw_multi_aff *pma);
__isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(
        __isl_take isl_pw_multi_aff *pma);

#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
        __isl_keep isl_pw_qpolynomial *pwqp);
__isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(
        __isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_copy(
        __isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_null isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_free(
        __isl_take isl_pw_qpolynomial_fold *pwf);

To iterate over the different cells of a piecewise expression, use the following functions.

#include <isl/aff.h>
isl_bool isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
isl_size isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
isl_stat isl_pw_aff_foreach_piece(
        __isl_keep isl_pw_aff *pwaff,
        isl_stat (*fn)(__isl_take isl_set *set,
                  __isl_take isl_aff *aff,
                  void *user), void *user);
isl_bool isl_pw_aff_every_piece(__isl_keep isl_pw_aff *pa,
        isl_bool (*test)(__isl_keep isl_set *set,
                __isl_keep isl_aff *aff, void *user),
                void *user);
isl_size isl_pw_multi_aff_n_piece(
        __isl_keep isl_pw_multi_aff *pma);
isl_stat isl_pw_multi_aff_foreach_piece(
        __isl_keep isl_pw_multi_aff *pma,
        isl_stat (*fn)(__isl_take isl_set *set,
                    __isl_take isl_multi_aff *maff,
                    void *user), void *user);
isl_bool isl_pw_multi_aff_every_piece(
        __isl_keep isl_pw_multi_aff *pma,
        isl_bool (*test)(__isl_keep isl_set *set,
                __isl_keep isl_multi_aff *ma, void *user),
                void *user);

#include <isl/polynomial.h>
isl_size isl_pw_qpolynomial_n_piece(
        __isl_keep isl_pw_qpolynomial *pwqp);
isl_stat isl_pw_qpolynomial_foreach_piece(
        __isl_keep isl_pw_qpolynomial *pwqp,
        isl_stat (*fn)(__isl_take isl_set *set,
                  __isl_take isl_qpolynomial *qp,
                  void *user), void *user);
isl_bool isl_pw_qpolynomial_every_piece(
        __isl_keep isl_pw_qpolynomial *pwqp,
        isl_bool (*test)(__isl_keep isl_set *set,
                __isl_keep isl_qpolynomial *qp,
                void *user), void *user);
isl_stat isl_pw_qpolynomial_foreach_lifted_piece(
        __isl_keep isl_pw_qpolynomial *pwqp,
        isl_stat (*fn)(__isl_take isl_set *set,
                  __isl_take isl_qpolynomial *qp,
                  void *user), void *user);
isl_size isl_pw_qpolynomial_fold_n_piece(
        __isl_keep isl_pw_qpolynomial_fold *pwf);
isl_stat isl_pw_qpolynomial_fold_foreach_piece(
        __isl_keep isl_pw_qpolynomial_fold *pwf,
        isl_stat (*fn)(__isl_take isl_set *set,
                  __isl_take isl_qpolynomial_fold *fold,
                  void *user), void *user);
isl_bool isl_pw_qpolynomial_fold_every_piece(
        __isl_keep isl_pw_qpolynomial_fold *pwf,
        isl_bool (*test)(__isl_keep isl_set *set,
                __isl_keep isl_qpolynomial_fold *fold,
                void *user), void *user);
isl_stat isl_pw_qpolynomial_fold_foreach_lifted_piece(
        __isl_keep isl_pw_qpolynomial_fold *pwf,
        isl_stat (*fn)(__isl_take isl_set *set,
                  __isl_take isl_qpolynomial_fold *fold,
                  void *user), void *user);

As usual, the function fn should return isl_stat_ok on success and isl_stat_error on failure. The difference between isl_pw_qpolynomial_foreach_piece and isl_pw_qpolynomial_foreach_lifted_piece is that isl_pw_qpolynomial_foreach_lifted_piece will first compute unique representations for all existentially quantified variables and then turn these existentially quantified variables into extra set variables, adapting the associated quasipolynomial accordingly. This means that the set passed to fn will not have any existentially quantified variables, but that the dimensions of the sets may be different for different invocations of fn. Similarly for isl_pw_qpolynomial_fold_foreach_piece and isl_pw_qpolynomial_fold_foreach_lifted_piece. The function isl_pw_aff_every_piece and its variants check whether each call to the callback returns true and stop checking as soon as one of these calls returns false (or error).

A piecewise expression consisting of the expressions at a given position of a piecewise multiple expression can be extracted using the following function.

#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_multi_aff_get_at(
        __isl_keep isl_pw_multi_aff *pma, int pos);
__isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
        __isl_keep isl_pw_multi_aff *pma, int pos);

isl_pw_multi_aff_get_pw_aff is an alternative name for isl_pw_multi_aff_get_at.

These expressions can be replaced using the following function.

#include <isl/aff.h>
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
        __isl_take isl_pw_multi_aff *pma, unsigned pos,
        __isl_take isl_pw_aff *pa);

Note that there is a difference between isl_multi_pw_aff and isl_pw_multi_aff objects. The first is a sequence of piecewise affine expressions, while the second is a piecewise sequence of affine expressions. In particular, each of the piecewise affine expressions in an isl_multi_pw_aff may have a different domain, while all multiple expressions associated to a cell in an isl_pw_multi_aff have the same domain. It is possible to convert between the two, but when converting an isl_multi_pw_aff to an isl_pw_multi_aff, the domain of the result is the intersection of the domains of the input. The reverse conversion is exact.

#include <isl/aff.h>
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_from_multi_pw_aff(
        __isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_pw_aff *
isl_pw_multi_aff_to_multi_pw_aff(
        __isl_take isl_pw_multi_aff *pma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_from_pw_multi_aff(
        __isl_take isl_pw_multi_aff *pma);

isl_pw_multi_aff_to_multi_pw_aff and isl_multi_pw_aff_from_pw_multi_aff perform the same operation.

Union Expressions

A union expression collects base expressions defined over different domains. The space of a union expression is that of the shared parameter space.

The union expression types defined by isl are isl_union_pw_aff, isl_union_pw_multi_aff, isl_union_pw_qpolynomial and isl_union_pw_qpolynomial_fold. In case of isl_union_pw_aff, isl_union_pw_qpolynomial and isl_union_pw_qpolynomial_fold, there can be at most one base expression for a given domain space. In case of isl_union_pw_multi_aff, there can be multiple such expressions for a given domain space, but the domains of these expressions need to be disjoint.

An empty union expression can be created using the following functions.

#include <isl/aff.h>
__isl_give isl_union_pw_aff *
isl_union_pw_aff_empty_ctx(
        isl_ctx *ctx);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_empty_space(
        __isl_take isl_space *space);
__isl_give isl_union_pw_aff *isl_union_pw_aff_empty(
        __isl_take isl_space *space);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_empty_ctx(
        isl_ctx *ctx);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_empty_space(
        __isl_take isl_space *space);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_empty(
        __isl_take isl_space *space);

#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_zero_ctx(
        isl_ctx *ctx);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_zero_space(
        __isl_take isl_space *space);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_zero(
        __isl_take isl_space *space);

isl_union_pw_aff_empty is an alternative name for isl_union_pw_aff_empty_space. Similarly for the other pairs of functions.

A union expression containing a single base expression can be created using the following functions.

#include <isl/aff.h>
__isl_give isl_union_pw_aff *
isl_pw_aff_to_union_pw_aff(
        __isl_take isl_pw_aff *pa);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_from_pw_aff(
        __isl_take isl_pw_aff *pa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_aff(
        __isl_take isl_aff *aff);
__isl_give isl_union_pw_multi_aff *
isl_pw_multi_aff_to_union_pw_multi_aff(
        __isl_take isl_pw_multi_aff *pma);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_pw_multi_aff(
        __isl_take isl_pw_multi_aff *pma);

#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_pw_qpolynomial_to_union_pw_qpolynomial(
        __isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_from_pw_qpolynomial(
        __isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_union_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(
        __isl_take isl_pw_qpolynomial_fold *pwf);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold(
        __isl_take isl_pw_qpolynomial_fold *pwf);

isl_pw_aff_to_union_pw_aff and isl_union_pw_aff_from_pw_aff perform the same operation. Similarly for isl_pw_multi_aff_to_union_pw_multi_aff and isl_union_pw_multi_aff_from_pw_multi_aff, for isl_pw_qpolynomial_to_union_pw_qpolynomial and isl_union_pw_qpolynomial_from_pw_qpolynomial, and for isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold and isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold.

The inverse conversions below can only be used if the input expression is known to live in exactly one space.

#include <isl/aff.h>
isl_bool isl_union_pw_multi_aff_isa_pw_multi_aff(
        __isl_keep isl_union_pw_multi_aff *upma);
__isl_give isl_pw_multi_aff *
isl_union_pw_multi_aff_as_pw_multi_aff(
        __isl_take isl_union_pw_multi_aff *upma);

A union piecewise expression containing a single base expression on a universe domain can also be created directly from a base expression using the following functions.

#include <isl/aff.h>
__isl_give isl_union_pw_aff *isl_union_pw_aff_from_aff(
        __isl_take isl_aff *aff);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_multi_aff(
        __isl_take isl_multi_aff *ma);

The following functions create a base expression on each of the sets in the union set and collect the results.

#include <isl/aff.h>
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_union_pw_aff(
        __isl_take isl_union_pw_aff *upa);
__isl_give isl_union_pw_aff *
isl_union_pw_multi_aff_get_union_pw_aff(
        __isl_keep isl_union_pw_multi_aff *upma, int pos);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_val_on_domain(
        __isl_take isl_union_set *domain,
        __isl_take isl_val *v);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_multi_val_on_domain(
        __isl_take isl_union_set *domain,
        __isl_take isl_multi_val *mv);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_param_on_domain_id(
        __isl_take isl_union_set *domain,
        __isl_take isl_id *id);

The id argument of isl_union_pw_aff_param_on_domain_id is the identifier of a parameter that may or may not already be present in domain.

An isl_union_pw_aff that is equal to a (parametric) affine or piecewise affine expression on a given domain can be created using the following functions.

#include <isl/aff.h>
__isl_give isl_union_pw_aff *
isl_union_pw_aff_aff_on_domain(
        __isl_take isl_union_set *domain,
        __isl_take isl_aff *aff);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_pw_aff_on_domain(
        __isl_take isl_union_set *domain,
        __isl_take isl_pw_aff *pa);

A base expression can be added to a union expression using the following functions.

#include <isl/aff.h>
__isl_give isl_union_pw_aff *
isl_union_pw_aff_add_pw_aff(
        __isl_take isl_union_pw_aff *upa,
        __isl_take isl_pw_aff *pa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_add_pw_multi_aff(
        __isl_take isl_union_pw_multi_aff *upma,
        __isl_take isl_pw_multi_aff *pma);

#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_add_pw_qpolynomial(
        __isl_take isl_union_pw_qpolynomial *upwqp,
        __isl_take isl_pw_qpolynomial *pwqp);

Union expressions can be copied and freed using the following functions.

#include <isl/aff.h>
__isl_give isl_union_pw_aff *isl_union_pw_aff_copy(
        __isl_keep isl_union_pw_aff *upa);
__isl_null isl_union_pw_aff *isl_union_pw_aff_free(
        __isl_take isl_union_pw_aff *upa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_copy(
        __isl_keep isl_union_pw_multi_aff *upma);
__isl_null isl_union_pw_multi_aff *
isl_union_pw_multi_aff_free(
        __isl_take isl_union_pw_multi_aff *upma);

#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_copy(
        __isl_keep isl_union_pw_qpolynomial *upwqp);
__isl_null isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_free(
        __isl_take isl_union_pw_qpolynomial *upwqp);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_copy(
        __isl_keep isl_union_pw_qpolynomial_fold *upwf);
__isl_null isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_free(
        __isl_take isl_union_pw_qpolynomial_fold *upwf);

To iterate over the base expressions in a union expression, use the following functions.

#include <isl/aff.h>
isl_size isl_union_pw_aff_n_pw_aff(
        __isl_keep isl_union_pw_aff *upa);
isl_stat isl_union_pw_aff_foreach_pw_aff(
        __isl_keep isl_union_pw_aff *upa,
        isl_stat (*fn)(__isl_take isl_pw_aff *pa,
                void *user), void *user);
isl_bool isl_union_pw_aff_every_pw_aff(
        __isl_keep isl_union_pw_aff *upa,
        isl_bool (*test)(__isl_keep isl_pw_aff *pa,
                void *user), void *user);
isl_size isl_union_pw_multi_aff_n_pw_multi_aff(
        __isl_keep isl_union_pw_multi_aff *upma);
isl_stat isl_union_pw_multi_aff_foreach_pw_multi_aff(
        __isl_keep isl_union_pw_multi_aff *upma,
        isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma,
                    void *user), void *user);
isl_bool isl_union_pw_multi_aff_every_pw_multi_aff(
        __isl_keep isl_union_pw_multi_aff *upma,
        isl_bool (*test)(
                __isl_keep isl_pw_multi_aff *pma,
                void *user), void *user);

#include <isl/polynomial.h>
isl_size isl_union_pw_qpolynomial_n_pw_qpolynomial(
        __isl_keep isl_union_pw_qpolynomial *upwqp);
isl_stat isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
        __isl_keep isl_union_pw_qpolynomial *upwqp,
        isl_stat (*fn)(__isl_take isl_pw_qpolynomial *pwqp,
                    void *user), void *user);
isl_bool isl_union_pw_qpolynomial_every_pw_qpolynomial(
        __isl_keep isl_union_pw_qpolynomial *upwqp,
        isl_bool (*test)(
                __isl_keep isl_pw_qpolynomial *pwqp,
                void *user), void *user);
isl_size isl_union_pw_qpolynomial_fold_n_pw_qpolynomial_fold(
        __isl_keep isl_union_pw_qpolynomial_fold *upwf);
isl_stat isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
        __isl_keep isl_union_pw_qpolynomial_fold *upwf,
        isl_stat (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
                    void *user), void *user);
isl_bool
isl_union_pw_qpolynomial_fold_every_pw_qpolynomial_fold(
        __isl_keep isl_union_pw_qpolynomial_fold *upwf,
        isl_bool (*test)(
                __isl_keep isl_pw_qpolynomial_fold *pwf,
                void *user), void *user);

To extract the base expression in a given space from a union, use the following functions.

#include <isl/aff.h>
__isl_give isl_pw_aff *isl_union_pw_aff_extract_pw_aff(
        __isl_keep isl_union_pw_aff *upa,
        __isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_union_pw_multi_aff_extract_pw_multi_aff(
        __isl_keep isl_union_pw_multi_aff *upma,
        __isl_take isl_space *space);

#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_union_pw_qpolynomial_extract_pw_qpolynomial(
        __isl_keep isl_union_pw_qpolynomial *upwqp,
        __isl_take isl_space *space);

It is also possible to obtain a list of the base expressions using the following functions.

#include <isl/aff.h>
__isl_give isl_pw_aff_list *
isl_union_pw_aff_get_pw_aff_list(
        __isl_keep isl_union_pw_aff *upa);
__isl_give isl_pw_multi_aff_list *
isl_union_pw_multi_aff_get_pw_multi_aff_list(
        __isl_keep isl_union_pw_multi_aff *upma);

#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial_list *
isl_union_pw_qpolynomial_get_pw_qpolynomial_list(
        __isl_keep isl_union_pw_qpolynomial *upwqp);
__isl_give isl_pw_qpolynomial_fold_list *
isl_union_pw_qpolynomial_fold_get_pw_qpolynomial_fold_list(
        __isl_keep isl_union_pw_qpolynomial_fold *upwf);

The returned list can be manipulated using the functions in "Lists".

Input and Output

For set and relation, isl supports its own input/output format, which is similar to the Omega format, but also supports the PolyLib format in some cases. For other object types, typically only an isl format is supported.

isl format

The isl format is similar to that of Omega, but has a different syntax for describing the parameters and allows for the definition of an existentially quantified variable as the integer division of an affine expression. For example, the set of integers i between 0 and n such that i % 10 <= 6 can be described as

[n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
                        i - 10 a <= 6) }

A set or relation can have several disjuncts, separated by the keyword or. Each disjunct is either a conjunction of constraints or a projection (exists) of a conjunction of constraints. The constraints are separated by the keyword and.

PolyLib format

If the represented set is a union, then the first line contains a single number representing the number of disjuncts. Otherwise, a line containing the number 1 is optional.

Each disjunct is represented by a matrix of constraints. The first line contains two numbers representing the number of rows and columns, where the number of rows is equal to the number of constraints and the number of columns is equal to two plus the number of variables. The following lines contain the actual rows of the constraint matrix. In each row, the first column indicates whether the constraint is an equality (0) or inequality (1). The final column corresponds to the constant term.

If the set is parametric, then the coefficients of the parameters appear in the last columns before the constant column. The coefficients of any existentially quantified variables appear between those of the set variables and those of the parameters.

Extended PolyLib format

The extended PolyLib format is nearly identical to the PolyLib format. The only difference is that the line containing the number of rows and columns of a constraint matrix also contains four additional numbers: the number of output dimensions, the number of input dimensions, the number of local dimensions (i.e., the number of existentially quantified variables) and the number of parameters. For sets, the number of ``output'' dimensions is equal to the number of set dimensions, while the number of ``input'' dimensions is zero.

Input

Objects can be read from input using the following functions.

#include <isl/id.h>
__isl_give isl_id *isl_id_read_from_str(isl_ctx *ctx,
        const char *str);
__isl_give isl_multi_id *isl_multi_id_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/val.h>
__isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,
        const char *str);
__isl_give isl_multi_val *isl_multi_val_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/space.h>
__isl_give isl_space *isl_space_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_read_from_file(
        isl_ctx *ctx, FILE *input);
__isl_give isl_basic_set *isl_basic_set_read_from_str(
        isl_ctx *ctx, const char *str);
__isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
        FILE *input);
__isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
        const char *str);

#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_read_from_file(
        isl_ctx *ctx, FILE *input);
__isl_give isl_basic_map *isl_basic_map_read_from_str(
        isl_ctx *ctx, const char *str);
__isl_give isl_map *isl_map_read_from_file(
        isl_ctx *ctx, FILE *input);
__isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
        const char *str);

#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_read_from_file(
        isl_ctx *ctx, FILE *input);
__isl_give isl_union_set *isl_union_set_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_read_from_file(
        isl_ctx *ctx, FILE *input);
__isl_give isl_union_map *isl_union_map_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/aff.h>
__isl_give isl_aff *isl_aff_read_from_str(
        isl_ctx *ctx, const char *str);
__isl_give isl_multi_aff *isl_multi_aff_read_from_str(
        isl_ctx *ctx, const char *str);
__isl_give isl_pw_aff *isl_pw_aff_read_from_str(
        isl_ctx *ctx, const char *str);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
        isl_ctx *ctx, const char *str);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(
        isl_ctx *ctx, const char *str);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_read_from_str(
        isl_ctx *ctx, const char *str);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_read_from_str(
        isl_ctx *ctx, const char *str);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_read_from_str(
        isl_ctx *ctx, const char *str);

__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_read_from_str(
        isl_ctx *ctx, const char *str);

For sets and relations, the input format is autodetected and may be either the PolyLib format or the isl format.

Output

Before anything can be printed, an isl_printer needs to be created.

__isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
        FILE *file);
__isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
__isl_null isl_printer *isl_printer_free(
        __isl_take isl_printer *printer);

isl_printer_to_file prints to the given file, while isl_printer_to_str prints to a string that can be extracted using the following function.

#include <isl/printer.h>
__isl_give char *isl_printer_get_str(
        __isl_keep isl_printer *printer);

The printer can be inspected using the following functions.

FILE *isl_printer_get_file(
        __isl_keep isl_printer *printer);
int isl_printer_get_output_format(
        __isl_keep isl_printer *p);
int isl_printer_get_yaml_style(__isl_keep isl_printer *p);

The behavior of the printer can be modified in various ways

__isl_give isl_printer *isl_printer_set_output_format(
        __isl_take isl_printer *p, int output_format);
__isl_give isl_printer *isl_printer_set_indent(
        __isl_take isl_printer *p, int indent);
__isl_give isl_printer *isl_printer_set_indent_prefix(
        __isl_take isl_printer *p, const char *prefix);
__isl_give isl_printer *isl_printer_indent(
        __isl_take isl_printer *p, int indent);
__isl_give isl_printer *isl_printer_set_prefix(
        __isl_take isl_printer *p, const char *prefix);
__isl_give isl_printer *isl_printer_set_suffix(
        __isl_take isl_printer *p, const char *suffix);
__isl_give isl_printer *isl_printer_set_yaml_style(
        __isl_take isl_printer *p, int yaml_style);

The output_format may be either ISL_FORMAT_ISL, ISL_FORMAT_OMEGA, ISL_FORMAT_POLYLIB, ISL_FORMAT_EXT_POLYLIB or ISL_FORMAT_LATEX and defaults to ISL_FORMAT_ISL. Each line in the output is prefixed by indent_prefix, indented by indent (set by isl_printer_set_indent) spaces (default: 0), prefixed by prefix and suffixed by suffix. In the PolyLib format output, the coefficients of the existentially quantified variables appear between those of the set variables and those of the parameters. The function isl_printer_indent increases the indentation by the specified amount (which may be negative). The YAML style may be either ISL_YAML_STYLE_BLOCK or ISL_YAML_STYLE_FLOW and when we are printing something in YAML format.

To actually print something, use

#include <isl/printer.h>
__isl_give isl_printer *isl_printer_print_double(
        __isl_take isl_printer *p, double d);

#include <isl/val.h>
__isl_give isl_printer *isl_printer_print_val(
        __isl_take isl_printer *p, __isl_keep isl_val *v);
__isl_give isl_printer *isl_printer_print_multi_val(
        __isl_take isl_printer *p,
        __isl_keep isl_multi_val *mv);

#include <isl/set.h>
__isl_give isl_printer *isl_printer_print_basic_set(
        __isl_take isl_printer *printer,
        __isl_keep isl_basic_set *bset);
__isl_give isl_printer *isl_printer_print_set(
        __isl_take isl_printer *printer,
        __isl_keep isl_set *set);

#include <isl/map.h>
__isl_give isl_printer *isl_printer_print_basic_map(
        __isl_take isl_printer *printer,
        __isl_keep isl_basic_map *bmap);
__isl_give isl_printer *isl_printer_print_map(
        __isl_take isl_printer *printer,
        __isl_keep isl_map *map);

#include <isl/union_set.h>
__isl_give isl_printer *isl_printer_print_union_set(
        __isl_take isl_printer *p,
        __isl_keep isl_union_set *uset);

#include <isl/union_map.h>
__isl_give isl_printer *isl_printer_print_union_map(
        __isl_take isl_printer *p,
        __isl_keep isl_union_map *umap);

#include <isl/id.h>
__isl_give isl_printer *isl_printer_print_multi_id(
        __isl_take isl_printer *p,
        __isl_keep isl_multi_id *mi);

#include <isl/aff.h>
__isl_give isl_printer *isl_printer_print_aff(
        __isl_take isl_printer *p, __isl_keep isl_aff *aff);
__isl_give isl_printer *isl_printer_print_multi_aff(
        __isl_take isl_printer *p,
        __isl_keep isl_multi_aff *maff);
__isl_give isl_printer *isl_printer_print_pw_aff(
        __isl_take isl_printer *p,
        __isl_keep isl_pw_aff *pwaff);
__isl_give isl_printer *isl_printer_print_pw_multi_aff(
        __isl_take isl_printer *p,
        __isl_keep isl_pw_multi_aff *pma);
__isl_give isl_printer *isl_printer_print_multi_pw_aff(
        __isl_take isl_printer *p,
        __isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_printer *isl_printer_print_union_pw_aff(
        __isl_take isl_printer *p,
        __isl_keep isl_union_pw_aff *upa);
__isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
        __isl_take isl_printer *p,
        __isl_keep isl_union_pw_multi_aff *upma);
__isl_give isl_printer *
isl_printer_print_multi_union_pw_aff(
        __isl_take isl_printer *p,
        __isl_keep isl_multi_union_pw_aff *mupa);

#include <isl/polynomial.h>
__isl_give isl_printer *isl_printer_print_qpolynomial(
        __isl_take isl_printer *p,
        __isl_keep isl_qpolynomial *qp);
__isl_give isl_printer *isl_printer_print_pw_qpolynomial(
        __isl_take isl_printer *p,
        __isl_keep isl_pw_qpolynomial *pwqp);
__isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
        __isl_take isl_printer *p,
        __isl_keep isl_union_pw_qpolynomial *upwqp);

__isl_give isl_printer *
isl_printer_print_pw_qpolynomial_fold(
        __isl_take isl_printer *p,
        __isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_give isl_printer *
isl_printer_print_union_pw_qpolynomial_fold(
        __isl_take isl_printer *p,
        __isl_keep isl_union_pw_qpolynomial_fold *upwf);

For isl_printer_print_qpolynomial, isl_printer_print_pw_qpolynomial and isl_printer_print_pw_qpolynomial_fold, the output format of the printer needs to be set to either ISL_FORMAT_ISL or ISL_FORMAT_C. For isl_printer_print_union_pw_qpolynomial and isl_printer_print_union_pw_qpolynomial_fold, only ISL_FORMAT_ISL is supported. In case of printing in ISL_FORMAT_C, the user may want to set the names of all dimensions first.

isl also provides limited support for printing YAML documents, just enough for the internal use for printing such documents.

#include <isl/printer.h>
__isl_give isl_printer *isl_printer_yaml_start_mapping(
        __isl_take isl_printer *p);
__isl_give isl_printer *isl_printer_yaml_end_mapping(
        __isl_take isl_printer *p);
__isl_give isl_printer *isl_printer_yaml_start_sequence(
        __isl_take isl_printer *p);
__isl_give isl_printer *isl_printer_yaml_end_sequence(
        __isl_take isl_printer *p);
__isl_give isl_printer *isl_printer_yaml_next(
        __isl_take isl_printer *p);

A document is started by a call to either isl_printer_yaml_start_mapping or isl_printer_yaml_start_sequence. Anything printed to the printer after such a call belong to the first key of the mapping or the first element in the sequence. The function isl_printer_yaml_next moves to the value if we are currently printing a mapping key, the next key if we are printing a value or the next element if we are printing an element in a sequence. Nested mappings and sequences are initiated by the same isl_printer_yaml_start_mapping or isl_printer_yaml_start_sequence. Each call to these functions needs to have a corresponding call to isl_printer_yaml_end_mapping or isl_printer_yaml_end_sequence.

When called on a file printer, the following function flushes the file. When called on a string printer, the buffer is cleared.

__isl_give isl_printer *isl_printer_flush(
        __isl_take isl_printer *p);

The following functions allow the user to attach notes to a printer in order to keep track of additional state.

#include <isl/printer.h>
isl_bool isl_printer_has_note(__isl_keep isl_printer *p,
        __isl_keep isl_id *id);
__isl_give isl_id *isl_printer_get_note(
        __isl_keep isl_printer *p, __isl_take isl_id *id);
__isl_give isl_printer *isl_printer_set_note(
        __isl_take isl_printer *p,
        __isl_take isl_id *id, __isl_take isl_id *note);

isl_printer_set_note associates the given note to the given identifier in the printer. isl_printer_get_note retrieves a note associated to an identifier, while isl_printer_has_note checks if there is such a note. isl_printer_get_note fails if the requested note does not exist.

Alternatively, a string representation can be obtained directly using the following functions, which always print in isl format.

#include <isl/id.h>
__isl_give char *isl_id_to_str(
        __isl_keep isl_id *id);
__isl_give char *isl_multi_id_to_str(
        __isl_keep isl_multi_id *mi);

#include <isl/space.h>
__isl_give char *isl_space_to_str(
        __isl_keep isl_space *space);

#include <isl/val.h>
__isl_give char *isl_val_to_str(__isl_keep isl_val *v);
__isl_give char *isl_multi_val_to_str(
        __isl_keep isl_multi_val *mv);

#include <isl/set.h>
__isl_give char *isl_basic_set_to_str(
        __isl_keep isl_basic_set *bset);
__isl_give char *isl_set_to_str(
        __isl_keep isl_set *set);

#include <isl/union_set.h>
__isl_give char *isl_union_set_to_str(
        __isl_keep isl_union_set *uset);

#include <isl/map.h>
__isl_give char *isl_basic_map_to_str(
        __isl_keep isl_basic_map *bmap);
__isl_give char *isl_map_to_str(
        __isl_keep isl_map *map);

#include <isl/union_map.h>
__isl_give char *isl_union_map_to_str(
        __isl_keep isl_union_map *umap);

#include <isl/aff.h>
__isl_give char *isl_aff_to_str(__isl_keep isl_aff *aff);
__isl_give char *isl_pw_aff_to_str(
        __isl_keep isl_pw_aff *pa);
__isl_give char *isl_multi_aff_to_str(
        __isl_keep isl_multi_aff *ma);
__isl_give char *isl_pw_multi_aff_to_str(
        __isl_keep isl_pw_multi_aff *pma);
__isl_give char *isl_multi_pw_aff_to_str(
        __isl_keep isl_multi_pw_aff *mpa);
__isl_give char *isl_union_pw_aff_to_str(
        __isl_keep isl_union_pw_aff *upa);
__isl_give char *isl_union_pw_multi_aff_to_str(
        __isl_keep isl_union_pw_multi_aff *upma);
__isl_give char *isl_multi_union_pw_aff_to_str(
        __isl_keep isl_multi_union_pw_aff *mupa);

#include <isl/point.h>
__isl_give char *isl_point_to_str(
        __isl_keep isl_point *pnt);

#include <isl/polynomial.h>
__isl_give char *isl_pw_qpolynomial_to_str(
        __isl_keep isl_pw_qpolynomial *pwqp);
__isl_give char *isl_union_pw_qpolynomial_to_str(
        __isl_keep isl_union_pw_qpolynomial *upwqp);

Properties

Unary Properties

Binary Properties

Unary Operations

Binary Operations

The two arguments of a binary operation not only need to live in the same isl_ctx, they currently also need to have the same (number of) parameters.

Basic Operations

Lexicographic Optimization

Given a (basic) set set (or bset) and a zero-dimensional domain dom, the following functions compute a set that contains the lexicographic minimum or maximum of the elements in set (or bset) for those values of the parameters that satisfy dom. If empty is not NULL, then *empty is assigned a set that contains the parameter values in dom for which set (or bset) has no elements. In other words, the union of the parameter values for which the result is non-empty and of *empty is equal to dom.

#include <isl/set.h>
__isl_give isl_set *isl_basic_set_partial_lexmin(
        __isl_take isl_basic_set *bset,
        __isl_take isl_basic_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_set *isl_basic_set_partial_lexmax(
        __isl_take isl_basic_set *bset,
        __isl_take isl_basic_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_set *isl_set_partial_lexmin(
        __isl_take isl_set *set, __isl_take isl_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_set *isl_set_partial_lexmax(
        __isl_take isl_set *set, __isl_take isl_set *dom,
        __isl_give isl_set **empty);

Given a (basic) set set (or bset), the following functions simply return a set containing the lexicographic minimum or maximum of the elements in set (or bset). In case of union sets, the optimum is computed per space.

#include <isl/set.h>
__isl_give isl_set *isl_basic_set_lexmin(
        __isl_take isl_basic_set *bset);
__isl_give isl_set *isl_basic_set_lexmax(
        __isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_lexmin(
        __isl_take isl_set *set);
__isl_give isl_set *isl_set_lexmax(
        __isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_lexmin(
        __isl_take isl_union_set *uset);
__isl_give isl_union_set *isl_union_set_lexmax(
        __isl_take isl_union_set *uset);

Given a (basic) relation map (or bmap) and a domain dom, the following functions compute a relation that maps each element of dom to the single lexicographic minimum or maximum of the elements that are associated to that same element in map (or bmap). If empty is not NULL, then *empty is assigned a set that contains the elements in dom that do not map to any elements in map (or bmap). In other words, the union of the domain of the result and of *empty is equal to dom.

#include <isl/map.h>
__isl_give isl_map *isl_basic_map_partial_lexmax(
        __isl_take isl_basic_map *bmap,
        __isl_take isl_basic_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_map *isl_basic_map_partial_lexmin(
        __isl_take isl_basic_map *bmap,
        __isl_take isl_basic_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_map *isl_map_partial_lexmax(
        __isl_take isl_map *map, __isl_take isl_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_map *isl_map_partial_lexmin(
        __isl_take isl_map *map, __isl_take isl_set *dom,
        __isl_give isl_set **empty);

Given a (basic) map map (or bmap), the following functions simply return a map mapping each element in the domain of map (or bmap) to the lexicographic minimum or maximum of all elements associated to that element. In case of union relations, the optimum is computed per space.

#include <isl/map.h>
__isl_give isl_map *isl_basic_map_lexmin(
        __isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_basic_map_lexmax(
        __isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_lexmin(
        __isl_take isl_map *map);
__isl_give isl_map *isl_map_lexmax(
        __isl_take isl_map *map);
__isl_give isl_union_map *isl_union_map_lexmin(
        __isl_take isl_union_map *umap);
__isl_give isl_union_map *isl_union_map_lexmax(
        __isl_take isl_union_map *umap);

The following functions return their result in the form of a piecewise multi-affine expression, but are otherwise equivalent to the corresponding functions returning a basic set or relation.

#include <isl/set.h>
__isl_give isl_pw_multi_aff *
isl_basic_set_partial_lexmin_pw_multi_aff(
        __isl_take isl_basic_set *bset,
        __isl_take isl_basic_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_pw_multi_aff *
isl_basic_set_partial_lexmax_pw_multi_aff(
        __isl_take isl_basic_set *bset,
        __isl_take isl_basic_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
        __isl_take isl_set *set);
__isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
        __isl_take isl_set *set);

#include <isl/map.h>
__isl_give isl_pw_multi_aff *
isl_basic_map_lexmin_pw_multi_aff(
        __isl_take isl_basic_map *bmap);
__isl_give isl_pw_multi_aff *
isl_basic_map_partial_lexmin_pw_multi_aff(
        __isl_take isl_basic_map *bmap,
        __isl_take isl_basic_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_pw_multi_aff *
isl_basic_map_partial_lexmax_pw_multi_aff(
        __isl_take isl_basic_map *bmap,
        __isl_take isl_basic_set *dom,
        __isl_give isl_set **empty);
__isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
        __isl_take isl_map *map);
__isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
        __isl_take isl_map *map);

The following functions return the lexicographic minimum or maximum on the shared domain of the inputs and the single defined function on those parts of the domain where only a single function is defined.

#include <isl/aff.h>
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
        __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_lexmax(
        __isl_take isl_pw_multi_aff *pma1,
        __isl_take isl_pw_multi_aff *pma2);

If the input to a lexicographic optimization problem has multiple constraints with the same coefficients for the optimized variables, then, by default, this symmetry is exploited by replacing those constraints by a single constraint with an abstract bound, which is in turn bounded by the corresponding terms in the original constraints. Without this optimization, the solver would typically consider all possible orderings of those original bounds, resulting in a needless decomposition of the domain. However, the optimization can also result in slowdowns since an extra parameter is introduced that may get used in additional integer divisions. The following option determines whether symmetry detection is applied during lexicographic optimization.

#include <isl/options.h>
isl_stat isl_options_set_pip_symmetry(isl_ctx *ctx,
        int val);
int isl_options_get_pip_symmetry(isl_ctx *ctx);

Ternary Operations

#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_cond(
        __isl_take isl_pw_aff *cond,
        __isl_take isl_pw_aff *pwaff_true,
        __isl_take isl_pw_aff *pwaff_false);

The function isl_pw_aff_cond performs a conditional operator and returns an expression that is equal to pwaff_true for elements where cond is non-zero and equal to pwaff_false for elements where cond is zero.

Lists

Lists are defined over several element types, including isl_val, isl_id, isl_aff, isl_pw_aff, isl_pw_multi_aff, isl_union_pw_aff, isl_union_pw_multi_aff, isl_qpolynomial, isl_pw_qpolynomial, isl_pw_qpolynomial_fold, isl_constraint, isl_basic_set, isl_set, isl_basic_map, isl_map, isl_union_set, isl_union_map, isl_ast_expr and isl_ast_node. Here we take lists of isl_sets as an example. Lists can be created, copied, modified and freed using the following functions.

#include <isl/set.h>
__isl_give isl_set_list *isl_set_to_list(
        __isl_take isl_set *el);
__isl_give isl_set_list *isl_set_list_from_set(
        __isl_take isl_set *el);
__isl_give isl_set_list *isl_set_list_alloc(
        isl_ctx *ctx, int n);
__isl_give isl_set_list *isl_set_list_copy(
        __isl_keep isl_set_list *list);
__isl_give isl_set_list *isl_set_list_insert(
        __isl_take isl_set_list *list, unsigned pos,
        __isl_take isl_set *el);
__isl_give isl_set_list *isl_set_list_add(
        __isl_take isl_set_list *list,
        __isl_take isl_set *el);
__isl_give isl_set_list *isl_set_list_drop(
        __isl_take isl_set_list *list,
        unsigned first, unsigned n);
__isl_give isl_set_list *isl_set_list_clear(
        __isl_take isl_set_list *list);
__isl_give isl_set_list *isl_set_list_swap(
        __isl_take isl_set_list *list,
        unsigned pos1, unsigned pos2);
__isl_give isl_set_list *isl_set_list_reverse(
        __isl_take isl_set_list *list);
__isl_give isl_set_list *isl_set_list_set_at(
        __isl_take isl_set_list *list, int index,
        __isl_take isl_set *set);
__isl_give isl_set_list *isl_set_list_set_set(
        __isl_take isl_set_list *list, int index,
        __isl_take isl_set *set);
__isl_give isl_set_list *isl_set_list_concat(
        __isl_take isl_set_list *list1,
        __isl_take isl_set_list *list2);
__isl_give isl_set_list *isl_set_list_map(
        __isl_take isl_set_list *list,
        __isl_give isl_set *(*fn)(__isl_take isl_set *el,
                void *user),
        void *user);
__isl_give isl_set_list *isl_set_list_sort(
        __isl_take isl_set_list *list,
        int (*cmp)(__isl_keep isl_set *a,
                __isl_keep isl_set *b, void *user),
        void *user);
__isl_null isl_set_list *isl_set_list_free(
        __isl_take isl_set_list *list);

isl_set_list_alloc creates an empty list with an initial capacity for n elements. isl_set_list_insert and isl_set_list_add add elements to a list, increasing its capacity as needed. isl_set_to_list creates a list with a single element. isl_set_list_from_set performs the same operation. isl_set_list_clear removes all elements from a list. isl_set_list_swap swaps the elements at the specified locations. isl_set_list_reverse reverses the elements in the list. isl_set_list_set_set is an alternative name for isl_set_list_set_at.

Lists can be inspected using the following functions.

#include <isl/set.h>
isl_size isl_set_list_size(__isl_keep isl_set_list *list);
isl_size isl_set_list_n_set(__isl_keep isl_set_list *list);
__isl_give isl_set *isl_set_list_get_at(
        __isl_keep isl_set_list *list, int index);
__isl_give isl_set *isl_set_list_get_set(
        __isl_keep isl_set_list *list, int index);
isl_stat isl_set_list_foreach(__isl_keep isl_set_list *list,
        isl_stat (*fn)(__isl_take isl_set *el, void *user),
        void *user);
isl_bool isl_set_list_every(__isl_keep isl_set_list *list,
        isl_bool (*test)(__isl_take isl_set *el,
                void *user),
        void *user);
isl_stat isl_set_list_foreach_scc(
        __isl_keep isl_set_list *list,
        isl_bool (*follows)(__isl_keep isl_set *a,
                __isl_keep isl_set *b, void *user),
        void *follows_user,
        isl_stat (*fn)(__isl_take isl_set_list *scc,
                void *user),
        void *fn_user);

isl_set_list_n_set is an alternative name for isl_set_list_size. Similarly, isl_set_list_get_set is an alternative name for isl_set_list_get_at. The function isl_set_list_foreach_scc calls fn on each of the strongly connected components of the graph with as vertices the elements of list and a directed edge from vertex b to vertex a iff follows(a, b) returns isl_bool_true. The callbacks follows and fn should return isl_bool_error or isl_stat_error on error.

Lists can be printed using

#include <isl/set.h>
__isl_give isl_printer *isl_printer_print_set_list(
        __isl_take isl_printer *p,
        __isl_keep isl_set_list *list);

Alternatively, a string representation can be obtained directly using the following function, which always prints in isl format.

#include <isl/set.h>
__isl_give char *isl_set_list_to_str(
        __isl_keep isl_set_list *list);

An isl_val_list, isl_id_list, isl_aff_list, isl_pw_aff_list, isl_pw_multi_aff_list, isl_union_pw_aff_list, isl_set_list, isl_map_list or isl_union_set_list object can also be read from input using the following functions.

#include <isl/val.h>
__isl_give isl_val_list *isl_val_list_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/id.h>
__isl_give isl_id_list *isl_id_list_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/aff.h>
__isl_give isl_aff_list *
isl_aff_list_read_from_str(isl_ctx *ctx,
        const char *str);
__isl_give isl_pw_aff_list *
isl_pw_aff_list_read_from_str(isl_ctx *ctx,
        const char *str);
__isl_give isl_pw_multi_aff_list *
isl_pw_multi_aff_list_read_from_str(isl_ctx *ctx,
        const char *str);
__isl_give isl_union_pw_aff_list *
isl_union_pw_aff_list_read_from_str(isl_ctx *ctx,
        const char *str);

#include <isl/set.h>
__isl_give isl_set_list *isl_set_list_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/map.h>
__isl_give isl_map_list *isl_map_list_read_from_str(
        isl_ctx *ctx, const char *str);

#include <isl/union_set.h>
__isl_give isl_union_set_list *
isl_union_set_list_read_from_str(isl_ctx *ctx,
        const char *str);

Associative arrays

Associative arrays map isl objects of a specific type to isl objects of some (other) specific type. They are defined for several pairs of types, including (isl_map, isl_basic_set), (isl_id, isl_ast_expr), (isl_id, isl_id) and (isl_id, isl_pw_aff). Here, we take associative arrays that map isl_ids to isl_ast_exprs as an example.

Associative arrays can be created, copied and freed using the following functions.

#include <isl/id_to_ast_expr.h>
__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_alloc(
        isl_ctx *ctx, int min_size);
__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_copy(
        __isl_keep isl_id_to_ast_expr *id2expr);
__isl_null isl_id_to_ast_expr *isl_id_to_ast_expr_free(
        __isl_take isl_id_to_ast_expr *id2expr);

The min_size argument to isl_id_to_ast_expr_alloc can be used to specify the expected size of the associative array. The associative array will be grown automatically as needed.

Associative arrays can be inspected using the following functions.

#include <isl/id_to_ast_expr.h>
__isl_give isl_maybe_isl_ast_expr
isl_id_to_ast_expr_try_get(
        __isl_keep isl_id_to_ast_expr *id2expr,
        __isl_keep isl_id *key);
isl_bool isl_id_to_ast_expr_has(
        __isl_keep isl_id_to_ast_expr *id2expr,
        __isl_keep isl_id *key);
__isl_give isl_ast_expr *isl_id_to_ast_expr_get(
        __isl_keep isl_id_to_ast_expr *id2expr,
        __isl_take isl_id *key);
isl_stat isl_id_to_ast_expr_foreach(
        __isl_keep isl_id_to_ast_expr *id2expr,
        isl_stat (*fn)(__isl_take isl_id *key,
                __isl_take isl_ast_expr *val, void *user),
        void *user);
isl_bool isl_id_to_ast_expr_every(
        __isl_keep isl_id_to_ast_expr *id2expr,
        isl_bool (*test)(__isl_keep isl_id *key,
                __isl_keep isl_ast_expr *val, void *user),
        void *user);

The function isl_id_to_ast_expr_try_get returns a structure containing two elements, valid and value. If there is a value associated to the key, then valid is set to isl_bool_true and value contains a copy of the associated value. Otherwise value is NULL and valid may be isl_bool_error or isl_bool_false depending on whether some error has occurred or there simply is no associated value. The function isl_id_to_ast_expr_has returns the valid field in the structure and the function isl_id_to_ast_expr_get returns the value field.

Associative arrays can be modified using the following functions.

#include <isl/id_to_ast_expr.h>
__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_set(
        __isl_take isl_id_to_ast_expr *id2expr,
        __isl_take isl_id *key,
        __isl_take isl_ast_expr *val);
__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_drop(
        __isl_take isl_id_to_ast_expr *id2expr,
        __isl_take isl_id *key);

Associative arrays can be checked for (obvious) equality using the following function.

#include <isl/id_to_ast_expr.h>
isl_bool isl_id_to_ast_expr_is_equal(
        __isl_take isl_id_to_ast_expr *id2expr1,
        __isl_take isl_id_to_ast_expr *id2expr2);

Note that depending on how the keys and values are being compared, for other types of keys and/or values, this function may be called plain_is_equal rather than is_equal.

Associative arrays can be printed using the following functions.

#include <isl/id_to_ast_expr.h>
__isl_give isl_printer *isl_printer_print_id_to_ast_expr(
        __isl_take isl_printer *p,
        __isl_keep isl_id_to_ast_expr *id2expr);
__isl_give char *isl_id_to_ast_expr_to_str(
        __isl_keep isl_id_to_ast_expr *id2expr);

They can be read from input using the following function.

#include <isl/id_to_ast_expr.h>
__isl_give isl_id_to_ast_expr *
isl_id_to_ast_expr_read_from_str(isl_ctx *ctx,
        const char *str);

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_zero(isl_ctx *ctx,
        unsigned size);
__isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
__isl_null isl_vec *isl_vec_free(__isl_take isl_vec *vec);

Note that the elements of a vector created by isl_vec_alloc may have arbitrary values. A vector created by isl_vec_zero has elements with value zero. The elements can be changed and inspected using the following functions.

isl_size isl_vec_size(__isl_keep isl_vec *vec);
__isl_give isl_val *isl_vec_get_element_val(
        __isl_keep isl_vec *vec, int pos);
__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_element_val(
        __isl_take isl_vec *vec, int pos,
        __isl_take isl_val *v);
__isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
        int v);
__isl_give isl_vec *isl_vec_set_val(
        __isl_take isl_vec *vec, __isl_take isl_val *v);
int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
        __isl_keep isl_vec *vec2, int pos);

isl_vec_get_element will return a negative value if anything went wrong. In that case, the value of *v is undefined.

The following function can be used to concatenate two vectors.

__isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,
        __isl_take isl_vec *vec2);

Matrices

Matrices can be created, copied and freed using the following functions.

#include <isl/mat.h>
__isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
        unsigned n_row, unsigned n_col);
__isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
__isl_null isl_mat *isl_mat_free(__isl_take isl_mat *mat);

Note that the elements of a newly created matrix may have arbitrary values. The elements can be changed and inspected using the following functions.

isl_size isl_mat_rows(__isl_keep isl_mat *mat);
isl_size isl_mat_cols(__isl_keep isl_mat *mat);
__isl_give isl_val *isl_mat_get_element_val(
        __isl_keep isl_mat *mat, int row, int col);
__isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
        int row, int col, int v);
__isl_give isl_mat *isl_mat_set_element_val(
        __isl_take isl_mat *mat, int row, int col,
        __isl_take isl_val *v);

The following function computes the rank of a matrix. The return value may be -1 if some error occurred.

#include <isl/mat.h>
isl_size isl_mat_rank(__isl_keep isl_mat *mat);

The following function can be used to compute the (right) inverse of a matrix, i.e., a matrix such that the product of the original and the inverse (in that order) is a multiple of the identity matrix. The input matrix is assumed to be of full row-rank.

__isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);

The following function can be used to compute the (right) kernel (or null space) of a matrix, i.e., a matrix such that the product of the original and the kernel (in that order) is the zero matrix.

__isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);

The following function computes a basis for the space spanned by the rows of a matrix.

__isl_give isl_mat *isl_mat_row_basis(
        __isl_take isl_mat *mat);

The following function computes rows that extend a basis of mat1 to a basis that also covers mat2.

__isl_give isl_mat *isl_mat_row_basis_extension(
        __isl_take isl_mat *mat1,
        __isl_take isl_mat *mat2);

The following function checks whether there is no linear dependence among the combined rows of "mat1" and "mat2" that is not already present in "mat1" or "mat2" individually. If "mat1" and "mat2" have linearly independent rows by themselves, then this means that there is no linear dependence among all rows together.

isl_bool isl_mat_has_linearly_independent_rows(
        __isl_keep isl_mat *mat1,
        __isl_keep isl_mat *mat2);

Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions

The following functions determine an upper or lower bound on a quasipolynomial over its domain.

__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_bound(
        __isl_take isl_pw_qpolynomial *pwqp,
        enum isl_fold type, isl_bool *tight);

__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_bound(
        __isl_take isl_union_pw_qpolynomial *upwqp,
        enum isl_fold type, isl_bool *tight);

The type argument may be either isl_fold_min or isl_fold_max. If tight is not NULL, then *tight is set to 1 is the returned bound is known be tight, i.e., for each value of the parameters there is at least one element in the domain that reaches the bound. If the domain of pwqp is not wrapping, then the bound is computed over all elements in that domain and the result has a purely parametric domain. If the domain of pwqp is wrapping, then the bound is computed over the range of the wrapped relation. The domain of the wrapped relation becomes the domain of the result.

Parametric Vertex Enumeration

The parametric vertex enumeration described in this section is mainly intended to be used internally and by the barvinok library.

#include <isl/vertices.h>
__isl_give isl_vertices *isl_basic_set_compute_vertices(
        __isl_keep isl_basic_set *bset);

The function isl_basic_set_compute_vertices performs the actual computation of the parametric vertices and the chamber decomposition and stores the result in an isl_vertices object. This information can be queried by either iterating over all the vertices or iterating over all the chambers or cells and then iterating over all vertices that are active on the chamber.

isl_stat isl_vertices_foreach_vertex(
        __isl_keep isl_vertices *vertices,
        isl_stat (*fn)(__isl_take isl_vertex *vertex,
                void *user), void *user);

isl_stat isl_vertices_foreach_cell(
        __isl_keep isl_vertices *vertices,
        isl_stat (*fn)(__isl_take isl_cell *cell,
                void *user), void *user);
isl_stat isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
        isl_stat (*fn)(__isl_take isl_vertex *vertex,
                void *user), void *user);

Other operations that can be performed on an isl_vertices object are the following.

isl_size isl_vertices_get_n_vertices(
        __isl_keep isl_vertices *vertices);
__isl_null isl_vertices *isl_vertices_free(
        __isl_take isl_vertices *vertices);

Vertices can be inspected and destroyed using the following functions.

isl_size isl_vertex_get_id(__isl_keep isl_vertex *vertex);
__isl_give isl_basic_set *isl_vertex_get_domain(
        __isl_keep isl_vertex *vertex);
__isl_give isl_multi_aff *isl_vertex_get_expr(
        __isl_keep isl_vertex *vertex);
__isl_null isl_vertex *isl_vertex_free(
        __isl_take isl_vertex *vertex);

isl_vertex_get_expr returns a multiple quasi-affine expression describing the vertex in terms of the parameters, while isl_vertex_get_domain returns the activity domain of the vertex.

Chambers can be inspected and destroyed using the following functions.

__isl_give isl_basic_set *isl_cell_get_domain(
        __isl_keep isl_cell *cell);
__isl_null isl_cell *isl_cell_free(
        __isl_take isl_cell *cell);

Polyhedral Compilation Library

This section collects functionality in isl that has been specifically designed for use during polyhedral compilation.

Schedule Trees

A schedule tree is a structured representation of a schedule, assigning a relative order to a set of domain elements. The relative order expressed by the schedule tree is defined recursively. In particular, the order between two domain elements is determined by the node that is closest to the root that refers to both elements and that orders them apart. Each node in the tree is of one of several types. The root node is always of type isl_schedule_node_domain (or isl_schedule_node_extension) and it describes the (extra) domain elements to which the schedule applies. The other types of nodes are as follows.

isl_schedule_node_band

A band of schedule dimensions. Each schedule dimension is represented by a union piecewise quasi-affine expression. If this expression assigns a different value to two domain elements, while all previous schedule dimensions in the same band assign them the same value, then the two domain elements are ordered according to these two different values. Each expression is required to be total in the domain elements that reach the band node.

isl_schedule_node_expansion

An expansion node maps each of the domain elements that reach the node to one or more domain elements. The image of this mapping forms the set of domain elements that reach the child of the expansion node. The function that maps each of the expanded domain elements to the original domain element from which it was expanded is called the contraction.

isl_schedule_node_filter

A filter node does not impose any ordering, but rather intersects the set of domain elements that the current subtree refers to with a given union set. The subtree of the filter node only refers to domain elements in the intersection. A filter node is typically only used as a child of a sequence or set node.

isl_schedule_node_leaf

A leaf of the schedule tree. Leaf nodes do not impose any ordering.

isl_schedule_node_mark

A mark node can be used to attach any kind of information to a subtree of the schedule tree.

isl_schedule_node_sequence

A sequence node has one or more children, each of which is a filter node. The filters on these filter nodes form a partition of the domain elements that the current subtree refers to. If two domain elements appear in distinct filters then the sequence node orders them according to the child positions of the corresponding filter nodes.

isl_schedule_node_set

A set node is similar to a sequence node, except that it expresses that domain elements appearing in distinct filters may have any order. The order of the children of a set node is therefore also immaterial.

The following node types are only supported by the AST generator.

isl_schedule_node_context

The context describes constraints on the parameters and the schedule dimensions of outer bands that the AST generator may assume to hold. It is also the only kind of node that may introduce additional parameters. The space of the context is that of the flat product of the outer band nodes. In particular, if there are no outer band nodes, then this space is the unnamed zero-dimensional space. Since a context node references the outer band nodes, any tree containing a context node is considered to be anchored.

isl_schedule_node_extension

An extension node instructs the AST generator to add additional domain elements that need to be scheduled. The additional domain elements are described by the range of the extension map in terms of the outer schedule dimensions, i.e., the flat product of the outer band nodes. Note that domain elements are added whenever the AST generator reaches the extension node, meaning that there are still some active domain elements for which an AST needs to be generated. The conditions under which some domain elements are still active may however not be completely described by the outer AST nodes generated at that point. Since an extension node references the outer band nodes, any tree containing an extension node is considered to be anchored.

An extension node may also appear as the root of a schedule tree, when it is intended to be inserted into another tree using isl_schedule_node_graft_before or isl_schedule_node_graft_after. In this case, the domain of the extension node should correspond to the flat product of the outer band nodes in this other schedule tree at the point where the extension tree will be inserted.

isl_schedule_node_guard

The guard describes constraints on the parameters and the schedule dimensions of outer bands that need to be enforced by the outer nodes in the generated AST. That is, the part of the AST that is generated from descendants of the guard node can assume that these constraints are satisfied. The space of the guard is that of the flat product of the outer band nodes. In particular, if there are no outer band nodes, then this space is the unnamed zero-dimensional space. Since a guard node references the outer band nodes, any tree containing a guard node is considered to be anchored.

Except for the isl_schedule_node_context nodes, none of the nodes may introduce any parameters that were not already present in the root domain node.

A schedule tree is encapsulated in an isl_schedule object. The simplest such objects, those with a tree consisting of single domain node, can be created using the following functions with either an empty domain or a given domain.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_empty(
        __isl_take isl_space *space);
__isl_give isl_schedule *isl_schedule_from_domain(
        __isl_take isl_union_set *domain);

The function isl_schedule_constraints_compute_schedule described in "Scheduling" can also be used to construct schedules.

isl_schedule objects may be copied and freed using the following functions.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_copy(
        __isl_keep isl_schedule *sched);
__isl_null isl_schedule *isl_schedule_free(
        __isl_take isl_schedule *sched);

The following functions checks whether two isl_schedule objects are obviously the same.

#include <isl/schedule.h>
isl_bool isl_schedule_plain_is_equal(
        __isl_keep isl_schedule *schedule1,
        __isl_keep isl_schedule *schedule2);

The domain of the schedule, i.e., the domain described by the root node, can be obtained using the following function.

#include <isl/schedule.h>
__isl_give isl_union_set *isl_schedule_get_domain(
        __isl_keep isl_schedule *schedule);

An extra top-level band node (right underneath the domain node) can be introduced into the schedule using the following function. The schedule tree is assumed not to have any anchored nodes.

#include <isl/schedule.h>
__isl_give isl_schedule *
isl_schedule_insert_partial_schedule(
        __isl_take isl_schedule *schedule,
        __isl_take isl_multi_union_pw_aff *partial);

A top-level context node (right underneath the domain node) can be introduced into the schedule using the following function.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_insert_context(
        __isl_take isl_schedule *schedule,
        __isl_take isl_set *context)

A top-level guard node (right underneath the domain node) can be introduced into the schedule using the following function.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_insert_guard(
        __isl_take isl_schedule *schedule,
        __isl_take isl_set *guard)

A schedule that combines two schedules either in the given order or in an arbitrary order, i.e., with an isl_schedule_node_sequence or an isl_schedule_node_set node, can be created using the following functions.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_sequence(
        __isl_take isl_schedule *schedule1,
        __isl_take isl_schedule *schedule2);
__isl_give isl_schedule *isl_schedule_set(
        __isl_take isl_schedule *schedule1,
        __isl_take isl_schedule *schedule2);

The domains of the two input schedules need to be disjoint.

The following function can be used to restrict the domain of a schedule with a domain node as root to be a subset of the given union set. This operation may remove nodes in the tree that have become redundant.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_intersect_domain(
        __isl_take isl_schedule *schedule,
        __isl_take isl_union_set *domain);

The following function can be used to simplify the domain of a schedule with a domain node as root with respect to the given parameter domain.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_gist_domain_params(
        __isl_take isl_schedule *schedule,
        __isl_take isl_set *context);

The following function resets the user pointers on all parameter and tuple identifiers referenced by the nodes of the given schedule.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_reset_user(
        __isl_take isl_schedule *schedule);

The following function aligns the parameters of all nodes in the given schedule to the given space.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_align_params(
        __isl_take isl_schedule *schedule,
        __isl_take isl_space *space);

The following function allows the user to plug in a given function in the iteration domains. The input schedule is not allowed to contain any expansion nodes.

#include <isl/schedule.h>
__isl_give isl_schedule *
isl_schedule_pullback_union_pw_multi_aff(
        __isl_take isl_schedule *schedule,
        __isl_take isl_union_pw_multi_aff *upma);

The following function can be used to plug in the schedule expansion in the leaves of schedule, where contraction describes how the domain elements of expansion map to the domain elements at the original leaves of schedule. The resulting schedule will contain expansion nodes, unless contraction is an identity function.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_expand(
        __isl_take isl_schedule *schedule,
        __isl_take isl_union_pw_multi_aff *contraction,
        __isl_take isl_schedule *expansion);

An isl_union_map representation of the schedule can be obtained from an isl_schedule using the following function.

#include <isl/schedule.h>
__isl_give isl_union_map *isl_schedule_get_map(
        __isl_keep isl_schedule *sched);

The resulting relation encodes the same relative ordering as the schedule by mapping the domain elements to a common schedule space. If the schedule_separate_components option is set, then the order of the children of a set node is explicitly encoded in the result. If the tree contains any expansion nodes, then the relation is formulated in terms of the expanded domain elements.

Schedules can be read from input using the following functions.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_read_from_file(
        isl_ctx *ctx, FILE *input);
__isl_give isl_schedule *isl_schedule_read_from_str(
        isl_ctx *ctx, const char *str);

A representation of the schedule can be printed using

#include <isl/schedule.h>
__isl_give isl_printer *isl_printer_print_schedule(
        __isl_take isl_printer *p,
        __isl_keep isl_schedule *schedule);
__isl_give char *isl_schedule_to_str(
        __isl_keep isl_schedule *schedule);

isl_schedule_to_str prints the schedule in flow format.

The schedule tree can be traversed through the use of isl_schedule_node objects that point to a particular position in the schedule tree. Whenever a isl_schedule_node is used to modify a node in the schedule tree, the original schedule tree is left untouched and the modifications are performed to a copy of the tree. The returned isl_schedule_node then points to this modified copy of the tree.

The root of the schedule tree can be obtained using the following function.

#include <isl/schedule.h>
__isl_give isl_schedule_node *isl_schedule_get_root(
        __isl_keep isl_schedule *schedule);

A pointer to a newly created schedule tree with a single domain node can be created using the following functions.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_from_domain(
        __isl_take isl_union_set *domain);
__isl_give isl_schedule_node *
isl_schedule_node_from_extension(
        __isl_take isl_union_map *extension);

isl_schedule_node_from_extension creates a tree with an extension node as root.

Schedule nodes can be copied and freed using the following functions.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_copy(
        __isl_keep isl_schedule_node *node);
__isl_null isl_schedule_node *isl_schedule_node_free(
        __isl_take isl_schedule_node *node);

The following functions can be used to check if two schedule nodes point to the same position in the same schedule.

#include <isl/schedule_node.h>
isl_bool isl_schedule_node_is_equal(
        __isl_keep isl_schedule_node *node1,
        __isl_keep isl_schedule_node *node2);

The following properties can be obtained from a schedule node.

#include <isl/schedule_node.h>
enum isl_schedule_node_type isl_schedule_node_get_type(
        __isl_keep isl_schedule_node *node);
enum isl_schedule_node_type
isl_schedule_node_get_parent_type(
        __isl_keep isl_schedule_node *node);
__isl_give isl_schedule *isl_schedule_node_get_schedule(
        __isl_keep isl_schedule_node *node);

The function isl_schedule_node_get_type returns the type of the node, while isl_schedule_node_get_parent_type returns type of the parent of the node, which is required to exist. The function isl_schedule_node_get_schedule returns a copy to the schedule to which the node belongs.

The following functions can be used to move the schedule node to a different position in the tree or to check if such a position exists.

#include <isl/schedule_node.h>
isl_bool isl_schedule_node_has_parent(
        __isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *isl_schedule_node_parent(
        __isl_take isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_grandparent(
        __isl_take isl_schedule_node *node);
__isl_give isl_schedule_node *isl_schedule_node_root(
        __isl_take isl_schedule_node *node);
__isl_give isl_schedule_node *isl_schedule_node_ancestor(
        __isl_take isl_schedule_node *node,
        int generation);
isl_size isl_schedule_node_n_children(
        __isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *isl_schedule_node_child(
        __isl_take isl_schedule_node *node, int pos);
isl_bool isl_schedule_node_has_children(
        __isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_grandchild(
        __isl_take isl_schedule_node *node,
        int pos1, int pos2);
__isl_give isl_schedule_node *isl_schedule_node_first_child(
        __isl_take isl_schedule_node *node);
isl_bool isl_schedule_node_has_previous_sibling(
        __isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_previous_sibling(
        __isl_take isl_schedule_node *node);
isl_bool isl_schedule_node_has_next_sibling(
        __isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_next_sibling(
        __isl_take isl_schedule_node *node);

For isl_schedule_node_ancestor, the ancestor of generation 0 is the node itself, the ancestor of generation 1 is its parent and so on.

It is also possible to query the number of ancestors of a node, the position of the current node within the children of its parent, the position of the subtree containing a node within the children of an ancestor or to obtain a copy of a given child without destroying the current node. Given two nodes that point to the same schedule, their closest shared ancestor can be obtained using isl_schedule_node_get_shared_ancestor.

#include <isl/schedule_node.h>
isl_size isl_schedule_node_get_tree_depth(
        __isl_keep isl_schedule_node *node);
isl_size isl_schedule_node_get_child_position(
        __isl_keep isl_schedule_node *node);
isl_size isl_schedule_node_get_ancestor_child_position(
        __isl_keep isl_schedule_node *node,
        __isl_keep isl_schedule_node *ancestor);
__isl_give isl_schedule_node *isl_schedule_node_get_child(
        __isl_keep isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_get_shared_ancestor(
        __isl_keep isl_schedule_node *node1,
        __isl_keep isl_schedule_node *node2);

All nodes in a schedule tree or all descendants of a specific node (including the node) can be visited in depth-first pre-order using the following functions.

#include <isl/schedule.h>
isl_stat isl_schedule_foreach_schedule_node_top_down(
        __isl_keep isl_schedule *sched,
        isl_bool (*fn)(__isl_keep isl_schedule_node *node,
                void *user), void *user);

#include <isl/schedule_node.h>
isl_stat isl_schedule_node_foreach_descendant_top_down(
        __isl_keep isl_schedule_node *node,
        isl_bool (*fn)(__isl_keep isl_schedule_node *node,
                void *user), void *user);

The callback function is slightly different from the usual callbacks in that it not only indicates success (non-negative result) or failure (negative result), but also indicates whether the children of the given node should be visited. In particular, if the callback returns a positive value, then the children are visited, but if the callback returns zero, then the children are not visited.

The following functions checks whether all descendants of a specific node (including the node itself) satisfy a user-specified test.

#include <isl/schedule_node.h>
isl_bool isl_schedule_node_every_descendant(
        __isl_keep isl_schedule_node *node,
        isl_bool (*test)(__isl_keep isl_schedule_node *node,
                void *user), void *user)

The ancestors of a node in a schedule tree can be visited from the root down to and including the parent of the node using the following function.

#include <isl/schedule_node.h>
isl_stat isl_schedule_node_foreach_ancestor_top_down(
        __isl_keep isl_schedule_node *node,
        isl_stat (*fn)(__isl_keep isl_schedule_node *node,
                void *user), void *user);

The following functions allows for a depth-first post-order traversal of the nodes in a schedule tree or of the descendants of a specific node (including the node itself), where the user callback is allowed to modify the visited node.

#include <isl/schedule.h>
__isl_give isl_schedule *
isl_schedule_map_schedule_node_bottom_up(
        __isl_take isl_schedule *schedule,
        __isl_give isl_schedule_node *(*fn)(
                __isl_take isl_schedule_node *node,
                void *user), void *user);

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_map_descendant_bottom_up(
        __isl_take isl_schedule_node *node,
        __isl_give isl_schedule_node *(*fn)(
                __isl_take isl_schedule_node *node,
                void *user), void *user);

The traversal continues from the node returned by the callback function. It is the responsibility of the user to ensure that this does not lead to an infinite loop. It is safest to always return a pointer to the same position (same ancestors and child positions) as the input node.

The following function removes a node (along with its descendants) from a schedule tree and returns a pointer to the leaf at the same position in the updated tree. It is not allowed to remove the root of a schedule tree or a child of a set or sequence node.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_cut(
        __isl_take isl_schedule_node *node);

The following function removes a single node from a schedule tree and returns a pointer to the child of the node, now located at the position of the original node or to a leaf node at that position if there was no child. It is not allowed to remove the root of a schedule tree, a set or sequence node, a child of a set or sequence node or a band node with an anchored subtree.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_delete(
        __isl_take isl_schedule_node *node);

Most nodes in a schedule tree only contain local information. In some cases, however, a node may also refer to the schedule dimensions of its outer band nodes. This means that the position of the node within the tree should not be changed, or at least that no changes are performed to the outer band nodes. The following function can be used to test whether the subtree rooted at a given node contains any such nodes.

#include <isl/schedule_node.h>
isl_bool isl_schedule_node_is_subtree_anchored(
        __isl_keep isl_schedule_node *node);

The following function resets the user pointers on all parameter and tuple identifiers referenced by the given schedule node.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_reset_user(
        __isl_take isl_schedule_node *node);

The following function aligns the parameters of the given schedule node to the given space.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_align_params(
        __isl_take isl_schedule_node *node,
        __isl_take isl_space *space);

Several node types have their own functions for querying (and in some cases setting) some node type specific properties.

#include <isl/schedule_node.h>
__isl_give isl_space *isl_schedule_node_band_get_space(
        __isl_keep isl_schedule_node *node);
__isl_give isl_multi_union_pw_aff *
isl_schedule_node_band_get_partial_schedule(
        __isl_keep isl_schedule_node *node);
__isl_give isl_union_map *
isl_schedule_node_band_get_partial_schedule_union_map(
        __isl_keep isl_schedule_node *node);
isl_size isl_schedule_node_band_n_member(
        __isl_keep isl_schedule_node *node);
isl_bool isl_schedule_node_band_member_get_coincident(
        __isl_keep isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_band_member_set_coincident(
        __isl_take isl_schedule_node *node, int pos,
        int coincident);
isl_bool isl_schedule_node_band_get_permutable(
        __isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_band_set_permutable(
        __isl_take isl_schedule_node *node, int permutable);
enum isl_ast_loop_type
isl_schedule_node_band_member_get_ast_loop_type(
        __isl_keep isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_band_member_set_ast_loop_type(
        __isl_take isl_schedule_node *node, int pos,
        enum isl_ast_loop_type type);
enum isl_ast_loop_type
isl_schedule_node_band_member_get_isolate_ast_loop_type(
        __isl_keep isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_band_member_set_isolate_ast_loop_type(
        __isl_take isl_schedule_node *node, int pos,
        enum isl_ast_loop_type type);
__isl_give isl_union_set *
isl_schedule_node_band_get_ast_build_options(
        __isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_band_set_ast_build_options(
        __isl_take isl_schedule_node *node,
        __isl_take isl_union_set *options);
__isl_give isl_set *
isl_schedule_node_band_get_ast_isolate_option(
        __isl_keep isl_schedule_node *node);

The function isl_schedule_node_band_get_space returns the space of the partial schedule of the band. The function isl_schedule_node_band_get_partial_schedule_union_map returns a representation of the partial schedule of the band node in the form of an isl_union_map. The coincident and permutable properties are set by isl_schedule_constraints_compute_schedule on the schedule tree it produces. A scheduling dimension is considered to be ``coincident'' if it satisfies the coincidence constraints within its band. That is, if the dependence distances of the coincidence constraints are all zero in that direction (for fixed iterations of outer bands). A band is marked permutable if it was produced using the Pluto-like scheduler. Note that the scheduler may have to resort to a Feautrier style scheduling step even if the default scheduler is used. An isl_ast_loop_type is one of isl_ast_loop_default, isl_ast_loop_atomic, isl_ast_loop_unroll or isl_ast_loop_separate. For the meaning of these loop AST generation types and the difference between the regular loop AST generation type and the isolate loop AST generation type, see "AST Generation Options (Schedule Tree)". The functions isl_schedule_node_band_member_get_ast_loop_type and isl_schedule_node_band_member_get_isolate_ast_loop_type may return isl_ast_loop_error if an error occurs. The AST build options govern how an AST is generated for the individual schedule dimensions during AST generation. See "AST Generation Options (Schedule Tree)". The isolate option for the given node can be extracted from these AST build options using the function isl_schedule_node_band_get_ast_isolate_option.

#include <isl/schedule_node.h>
__isl_give isl_set *
isl_schedule_node_context_get_context(
        __isl_keep isl_schedule_node *node);

#include <isl/schedule_node.h>
__isl_give isl_union_set *
isl_schedule_node_domain_get_domain(
        __isl_keep isl_schedule_node *node);

#include <isl/schedule_node.h>
__isl_give isl_union_map *
isl_schedule_node_expansion_get_expansion(
        __isl_keep isl_schedule_node *node);
__isl_give isl_union_pw_multi_aff *
isl_schedule_node_expansion_get_contraction(
        __isl_keep isl_schedule_node *node);

#include <isl/schedule_node.h>
__isl_give isl_union_map *
isl_schedule_node_extension_get_extension(
        __isl_keep isl_schedule_node *node);

#include <isl/schedule_node.h>
__isl_give isl_union_set *
isl_schedule_node_filter_get_filter(
        __isl_keep isl_schedule_node *node);

#include <isl/schedule_node.h>
__isl_give isl_set *isl_schedule_node_guard_get_guard(
        __isl_keep isl_schedule_node *node);

#include <isl/schedule_node.h>
__isl_give isl_id *isl_schedule_node_mark_get_id(
        __isl_keep isl_schedule_node *node);

The following functions can be used to obtain an isl_multi_union_pw_aff, an isl_union_pw_multi_aff or isl_union_map representation of partial schedules related to the node.

#include <isl/schedule_node.h>
__isl_give isl_multi_union_pw_aff *
isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(
        __isl_keep isl_schedule_node *node);
__isl_give isl_union_pw_multi_aff *
isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(
        __isl_keep isl_schedule_node *node);
__isl_give isl_union_map *
isl_schedule_node_get_prefix_schedule_union_map(
        __isl_keep isl_schedule_node *node);
__isl_give isl_union_map *
isl_schedule_node_get_prefix_schedule_relation(
        __isl_keep isl_schedule_node *node);
__isl_give isl_union_map *
isl_schedule_node_get_subtree_schedule_union_map(
        __isl_keep isl_schedule_node *node);

In particular, the functions isl_schedule_node_get_prefix_schedule_multi_union_pw_aff, isl_schedule_node_get_prefix_schedule_union_pw_multi_aff and isl_schedule_node_get_prefix_schedule_union_map return a relative ordering on the domain elements that reach the given node determined by its ancestors. The function isl_schedule_node_get_prefix_schedule_relation additionally includes the domain constraints in the result. The function isl_schedule_node_get_subtree_schedule_union_map returns a representation of the partial schedule defined by the subtree rooted at the given node. If the tree contains any expansion nodes, then the subtree schedule is formulated in terms of the expanded domain elements. The tree passed to functions returning a prefix schedule may only contain extension nodes if these would not affect the result of these functions. That is, if one of the ancestors is an extension node, then all of the domain elements that were added by the extension node need to have been filtered out by filter nodes between the extension node and the input node. The tree passed to isl_schedule_node_get_subtree_schedule_union_map may not contain in extension nodes in the selected subtree.

The expansion/contraction defined by an entire subtree, combining the expansions/contractions on the expansion nodes in the subtree, can be obtained using the following functions.

#include <isl/schedule_node.h>
__isl_give isl_union_map *
isl_schedule_node_get_subtree_expansion(
        __isl_keep isl_schedule_node *node);
__isl_give isl_union_pw_multi_aff *
isl_schedule_node_get_subtree_contraction(
        __isl_keep isl_schedule_node *node);

The total number of outer band members of given node, i.e., the shared output dimension of the maps in the result of isl_schedule_node_get_prefix_schedule_union_map can be obtained using the following function.

#include <isl/schedule_node.h>
isl_size isl_schedule_node_get_schedule_depth(
        __isl_keep isl_schedule_node *node);

The following functions return the elements that reach the given node or the union of universes in the spaces that contain these elements.

#include <isl/schedule_node.h>
__isl_give isl_union_set *
isl_schedule_node_get_domain(
        __isl_keep isl_schedule_node *node);
__isl_give isl_union_set *
isl_schedule_node_get_universe_domain(
        __isl_keep isl_schedule_node *node);

The input tree of isl_schedule_node_get_domain may only contain extension nodes if these would not affect the result of this function. That is, if one of the ancestors is an extension node, then all of the domain elements that were added by the extension node need to have been filtered out by filter nodes between the extension node and the input node.

The following functions can be used to introduce additional nodes in the schedule tree. The new node is introduced at the point in the tree where the isl_schedule_node points to and the results points to the new node.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_partial_schedule(
        __isl_take isl_schedule_node *node,
        __isl_take isl_multi_union_pw_aff *schedule);

This function inserts a new band node with (the greatest integer part of) the given partial schedule. The subtree rooted at the given node is assumed not to have any anchored nodes.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_context(
        __isl_take isl_schedule_node *node,
        __isl_take isl_set *context);

This function inserts a new context node with the given context constraints.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_filter(
        __isl_take isl_schedule_node *node,
        __isl_take isl_union_set *filter);

This function inserts a new filter node with the given filter. If the original node already pointed to a filter node, then the two filter nodes are merged into one.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_guard(
        __isl_take isl_schedule_node *node,
        __isl_take isl_set *guard);

This function inserts a new guard node with the given guard constraints.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_mark(
        __isl_take isl_schedule_node *node,
        __isl_take isl_id *mark);

This function inserts a new mark node with the give mark identifier.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_sequence(
        __isl_take isl_schedule_node *node,
        __isl_take isl_union_set_list *filters);
__isl_give isl_schedule_node *
isl_schedule_node_insert_set(
        __isl_take isl_schedule_node *node,
        __isl_take isl_union_set_list *filters);

These functions insert a new sequence or set node with the given filters as children.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_group(
        __isl_take isl_schedule_node *node,
        __isl_take isl_id *group_id);

This function introduces an expansion node in between the current node and its parent that expands instances of a space with tuple identifier group_id to the original domain elements that reach the node. The group instances are identified by the prefix schedule of those domain elements. The ancestors of the node are adjusted to refer to the group instances instead of the original domain elements. The return value points to the same node in the updated schedule tree as the input node, i.e., to the child of the newly introduced expansion node. Grouping instances of different statements ensures that they will be treated as a single statement by the AST generator up to the point of the expansion node.

The following functions can be used to flatten a nested sequence.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_sequence_splice_child(
        __isl_take isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_sequence_splice_children(
        __isl_take isl_schedule_node *node);

That is, given a sequence node node that has another sequence node in its child at position pos (in particular, the child of that filter node is a sequence node), the function isl_schedule_node_sequence_splice_child attaches the children of that other sequence node as children of node, replacing the original child at position pos. isl_schedule_node_sequence_splice_children does this for all such children.

The partial schedule of a band node can be scaled (down) or reduced using the following functions.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_band_scale(
        __isl_take isl_schedule_node *node,
        __isl_take isl_multi_val *mv);
__isl_give isl_schedule_node *
isl_schedule_node_band_scale_down(
        __isl_take isl_schedule_node *node,
        __isl_take isl_multi_val *mv);
__isl_give isl_schedule_node *
isl_schedule_node_band_mod(
        __isl_take isl_schedule_node *node,
        __isl_take isl_multi_val *mv);

The spaces of the two arguments need to match. After scaling, the partial schedule is replaced by its greatest integer part to ensure that the schedule remains integral.

The partial schedule of a band node can be shifted by an isl_multi_union_pw_aff with a domain that is a superset of the domain of the partial schedule using the following function.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_band_shift(
        __isl_take isl_schedule_node *node,
        __isl_take isl_multi_union_pw_aff *shift);

A band node can be tiled using the following function.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_band_tile(
        __isl_take isl_schedule_node *node,
        __isl_take isl_multi_val *sizes);

isl_stat isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
        int val);
int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
isl_stat isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
        int val);
int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);

The isl_schedule_node_band_tile function tiles the band using the given tile sizes inside its schedule. A new child band node is created to represent the point loops and it is inserted between the modified band and its children. The subtree rooted at the given node is assumed not to have any anchored nodes. The tile_scale_tile_loops option specifies whether the tile loops iterators should be scaled by the tile sizes. If the tile_shift_point_loops option is set, then the point loops are shifted to start at zero.

A band node can be split into two nested band nodes using the following function.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_band_split(
        __isl_take isl_schedule_node *node, int pos);

The resulting outer band node contains the first pos dimensions of the schedule of node while the inner band contains the remaining dimensions. The schedules of the two band nodes live in anonymous spaces. The loop AST generation type options and the isolate option are split over the two band nodes.

A band node can be moved down to the leaves of the subtree rooted at the band node using the following function.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_band_sink(
        __isl_take isl_schedule_node *node);

The subtree rooted at the given node is assumed not to have any anchored nodes. The result points to the node in the resulting tree that is in the same position as the node pointed to by node in the original tree.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_order_before(
        __isl_take isl_schedule_node *node,
        __isl_take isl_union_set *filter);
__isl_give isl_schedule_node *
isl_schedule_node_order_after(
        __isl_take isl_schedule_node *node,
        __isl_take isl_union_set *filter);

These functions split the domain elements that reach node into those that satisfy filter and those that do not and arranges for the elements that do satisfy the filter to be executed before (in case of isl_schedule_node_order_before) or after (in case of isl_schedule_node_order_after) those that do not. The order is imposed by a sequence node, possibly reusing the grandparent of node on two copies of the subtree attached to the original node. Both copies are simplified with respect to their filter.

Return a pointer to the copy of the subtree that does not satisfy filter. If there is no such copy (because all reaching domain elements satisfy the filter), then return the original pointer.

#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_graft_before(
        __isl_take isl_schedule_node *node,
        __isl_take isl_schedule_node *graft);
__isl_give isl_schedule_node *
isl_schedule_node_graft_after(
        __isl_take isl_schedule_node *node,
        __isl_take isl_schedule_node *graft);

This function inserts the graft tree into the tree containing node such that it is executed before (in case of isl_schedule_node_graft_before) or after (in case of isl_schedule_node_graft_after) node. The root node of graft should be an extension node where the domain of the extension is the flat product of all outer band nodes of node. The root node may also be a domain node. The elements of the domain or the range of the extension may not intersect with the domain elements that reach "node". The schedule tree of graft may not be anchored.

The schedule tree of node is modified to include an extension node corresponding to the root node of graft as a child of the original parent of node. The original node that node points to and the child of the root node of graft are attached to this extension node through a sequence, with appropriate filters and with the child of graft appearing before or after the original node.

If node already appears inside a sequence that is the child of an extension node and if the spaces of the new domain elements do not overlap with those of the original domain elements, then that extension node is extended with the new extension rather than introducing a new segment of extension and sequence nodes.

Return a pointer to the same node in the modified tree that node pointed to in the original tree.

A representation of the schedule node can be printed using

#include <isl/schedule_node.h>
__isl_give isl_printer *isl_printer_print_schedule_node(
        __isl_take isl_printer *p,
        __isl_keep isl_schedule_node *node);
__isl_give char *isl_schedule_node_to_str(
        __isl_keep isl_schedule_node *node);

isl_schedule_node_to_str prints the schedule node in block format.

Dependence Analysis

isl contains specialized functionality for performing array dataflow analysis. That is, given a sink access relation, a collection of possible source accesses and a collection of kill accesses, isl can compute relations that describe for each iteration of the sink access, which iterations of which of the source access relations may have accessed the same data element before the given iteration of the sink access without any intermediate kill of that data element. The resulting dependence relations map source iterations to either the corresponding sink iterations or pairs of corresponding sink iterations and accessed data elements. To compute standard flow dependences, the sink should be a read, while the sources should be writes. If no kills are specified, then memory based dependence analysis is performed. If, on the other hand, all sources are also kills, then value based dependence analysis is performed. If any of the source accesses are marked as being must accesses, then they are also treated as kills. Furthermore, the specification of must-sources results in the computation of must-dependences. Only dependences originating in a must access not coscheduled with any other access to the same element and without any may accesses between the must access and the sink access are considered to be must dependences.

High-level Interface

A high-level interface to dependence analysis is provided by the following function.

#include <isl/flow.h>
__isl_give isl_union_flow *
isl_union_access_info_compute_flow(
        __isl_take isl_union_access_info *access);

The input isl_union_access_info object describes the sink access relations, the source access relations and a schedule, while the output isl_union_flow object describes the resulting dependence relations and the subsets of the sink relations for which no source was found.

An isl_union_access_info is created, modified, copied and freed using the following functions.

#include <isl/flow.h>
__isl_give isl_union_access_info *
isl_union_access_info_from_sink(
        __isl_take isl_union_map *sink);
__isl_give isl_union_access_info *
isl_union_access_info_set_kill(
        __isl_take isl_union_access_info *access,
        __isl_take isl_union_map *kill);
__isl_give isl_union_access_info *
isl_union_access_info_set_may_source(
        __isl_take isl_union_access_info *access,
        __isl_take isl_union_map *may_source);
__isl_give isl_union_access_info *
isl_union_access_info_set_must_source(
        __isl_take isl_union_access_info *access,
        __isl_take isl_union_map *must_source);
__isl_give isl_union_access_info *
isl_union_access_info_set_schedule(
        __isl_take isl_union_access_info *access,
        __isl_take isl_schedule *schedule);
__isl_give isl_union_access_info *
isl_union_access_info_set_schedule_map(
        __isl_take isl_union_access_info *access,
        __isl_take isl_union_map *schedule_map);
__isl_give isl_union_access_info *
isl_union_access_info_copy(
        __isl_keep isl_union_access_info *access);
__isl_null isl_union_access_info *
isl_union_access_info_free(
        __isl_take isl_union_access_info *access);

The may sources set by isl_union_access_info_set_may_source do not need to include the must sources set by isl_union_access_info_set_must_source as a subset. The kills set by isl_union_access_info_set_kill may overlap with the may-sources and/or must-sources. The user is free not to call one (or more) of these functions, in which case the corresponding set is kept to its empty default. Similarly, the default schedule initialized by isl_union_access_info_from_sink is empty. The current schedule is determined by the last call to either isl_union_access_info_set_schedule or isl_union_access_info_set_schedule_map. The domain of the schedule corresponds to the domains of the access relations. In particular, the domains of the access relations are effectively intersected with the domain of the schedule and only the resulting accesses are considered by the dependence analysis.

An isl_union_access_info object can be read from input using the following function.

#include <isl/flow.h>
__isl_give isl_union_access_info *
isl_union_access_info_read_from_file(isl_ctx *ctx,
        FILE *input);

A representation of the information contained in an object of type isl_union_access_info can be obtained using

#include <isl/flow.h>
__isl_give isl_printer *
isl_printer_print_union_access_info(
        __isl_take isl_printer *p,
        __isl_keep isl_union_access_info *access);
__isl_give char *isl_union_access_info_to_str(
        __isl_keep isl_union_access_info *access);

isl_union_access_info_to_str prints the information in flow format.

The output of isl_union_access_info_compute_flow can be examined, copied, and freed using the following functions.

#include <isl/flow.h>
__isl_give isl_union_map *isl_union_flow_get_must_dependence(
        __isl_keep isl_union_flow *flow);
__isl_give isl_union_map *isl_union_flow_get_may_dependence(
        __isl_keep isl_union_flow *flow);
__isl_give isl_union_map *
isl_union_flow_get_full_must_dependence(
        __isl_keep isl_union_flow *flow);
__isl_give isl_union_map *
isl_union_flow_get_full_may_dependence(
        __isl_keep isl_union_flow *flow);
__isl_give isl_union_map *isl_union_flow_get_must_no_source(
        __isl_keep isl_union_flow *flow);
__isl_give isl_union_map *isl_union_flow_get_may_no_source(
        __isl_keep isl_union_flow *flow);
__isl_give isl_union_flow *isl_union_flow_copy(
        __isl_keep isl_union_flow *flow);
__isl_null isl_union_flow *isl_union_flow_free(
        __isl_take isl_union_flow *flow);

The relation returned by isl_union_flow_get_must_dependence relates domain elements of must sources to domain elements of the sink. The relation returned by isl_union_flow_get_may_dependence relates domain elements of must or may sources to domain elements of the sink and includes the previous relation as a subset. The relation returned by isl_union_flow_get_full_must_dependence relates domain elements of must sources to pairs of domain elements of the sink and accessed data elements. The relation returned by isl_union_flow_get_full_may_dependence relates domain elements of must or may sources to pairs of domain elements of the sink and accessed data elements. This relation includes the previous relation as a subset. The relation returned by isl_union_flow_get_must_no_source is the subset of the sink relation for which no dependences have been found. The relation returned by isl_union_flow_get_may_no_source is the subset of the sink relation for which no definite dependences have been found. That is, it contains those sink access that do not contribute to any of the elements in the relation returned by isl_union_flow_get_must_dependence.

A representation of the information contained in an object of type isl_union_flow can be obtained using

#include <isl/flow.h>
__isl_give isl_printer *isl_printer_print_union_flow(
        __isl_take isl_printer *p,
        __isl_keep isl_union_flow *flow);
__isl_give char *isl_union_flow_to_str(
        __isl_keep isl_union_flow *flow);

isl_union_flow_to_str prints the information in flow format.

Low-level Interface

A lower-level interface is provided by the following functions.

#include <isl/flow.h>

typedef int (*isl_access_level_before)(void *first, void *second);

__isl_give isl_access_info *isl_access_info_alloc(
        __isl_take isl_map *sink,
        void *sink_user, isl_access_level_before fn,
        int max_source);
__isl_give isl_access_info *isl_access_info_add_source(
        __isl_take isl_access_info *acc,
        __isl_take isl_map *source, int must,
        void *source_user);
__isl_null isl_access_info *isl_access_info_free(
        __isl_take isl_access_info *acc);

__isl_give isl_flow *isl_access_info_compute_flow(
        __isl_take isl_access_info *acc);

isl_stat isl_flow_foreach(__isl_keep isl_flow *deps,
        isl_stat (*fn)(__isl_take isl_map *dep, int must,
                  void *dep_user, void *user),
        void *user);
__isl_give isl_map *isl_flow_get_no_source(
        __isl_keep isl_flow *deps, int must);
__isl_null isl_flow *isl_flow_free(
        __isl_take isl_flow *deps);

The function isl_access_info_compute_flow performs the actual dependence analysis. The other functions are used to construct the input for this function or to read off the output.

The input is collected in an isl_access_info, which can be created through a call to isl_access_info_alloc. The arguments to this functions are the sink access relation sink, a token sink_user used to identify the sink access to the user, a callback function for specifying the relative order of source and sink accesses, and the number of source access relations that will be added.

The callback function has type int (*)(void *first, void *second). The function is called with two user supplied tokens identifying either a source or the sink and it should return the shared nesting level and the relative order of the two accesses. In particular, let n be the number of loops shared by the two accesses. If first precedes second textually, then the function should return 2 * n + 1; otherwise, it should return 2 * n. The low-level interface assumes that no sources are coscheduled. If the information returned by the callback does not allow the relative order to be determined, then one of the sources is arbitrarily taken to be executed after the other(s).

The sources can be added to the isl_access_info object by performing (at most) max_source calls to isl_access_info_add_source. must indicates whether the source is a must access or a may access. Note that a multi-valued access relation should only be marked must if every iteration in the domain of the relation accesses all elements in its image. The source_user token is again used to identify the source access. The range of the source access relation source should have the same dimension as the range of the sink access relation. The isl_access_info_free function should usually not be called explicitly, because it is already called implicitly by isl_access_info_compute_flow.

The result of the dependence analysis is collected in an isl_flow. There may be elements of the sink access for which no preceding source access could be found or for which all preceding sources are may accesses. The relations containing these elements can be obtained through calls to isl_flow_get_no_source, the first with must set and the second with must unset. In the case of standard flow dependence analysis, with the sink a read and the sources must writes, the first relation corresponds to the reads from uninitialized array elements and the second relation is empty. The actual flow dependences can be extracted using isl_flow_foreach. This function will call the user-specified callback function fn for each non-empty dependence between a source and the sink. The callback function is called with four arguments, the actual flow dependence relation mapping source iterations to sink iterations, a boolean that indicates whether it is a must or may dependence, a token identifying the source and an additional void * with value equal to the third argument of the isl_flow_foreach call. A dependence is marked must if it originates from a must source and if it is not followed by any may sources.

After finishing with an isl_flow, the user should call isl_flow_free to free all associated memory.

Interaction with the Low-level Interface

During the dependence analysis, we frequently need to perform the following operation. Given a relation between sink iterations and potential source 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 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 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, isl provides the following function.

#include <isl/flow.h>

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 fn, void *user);

The function isl_access_info_set_restrict should be called before calling isl_access_info_compute_flow and registers a callback function that will be called any time 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 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 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 NULL. An isl_restriction object can be created, freed and inspected using the following functions.

#include <isl/flow.h>

__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_take isl_map *source_map);
__isl_give isl_restriction *isl_restriction_empty(
        __isl_take isl_map *source_map);
__isl_null isl_restriction *isl_restriction_free(
        __isl_take isl_restriction *restr);

isl_restriction_none and isl_restriction_empty are special cases of isl_restriction_input. 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 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))));

Scheduling

#include <isl/schedule.h>
__isl_give isl_schedule *
isl_schedule_constraints_compute_schedule(
        __isl_take isl_schedule_constraints *sc);

The function isl_schedule_constraints_compute_schedule can be used to compute a schedule that satisfies the given schedule constraints. These schedule constraints include the iteration domain for which a schedule should be computed and dependences between pairs of iterations. In particular, these dependences include validity dependences and proximity dependences. By default, the algorithm used to construct the schedule is similar to that of Pluto. Alternatively, Feautrier's multi-dimensional scheduling algorithm can be selected. The generated schedule respects all validity dependences. That is, all dependence distances over these dependences in the scheduled space are lexicographically positive.

The default algorithm tries to ensure that the dependence distances over coincidence constraints are zero and to minimize the dependence distances over proximity dependences. Moreover, it tries to obtain sequences (bands) of schedule dimensions for groups of domains where the dependence distances over validity dependences have only non-negative values. Note that when minimizing the maximal dependence distance over proximity dependences, a single affine expression in the parameters is constructed that bounds all dependence distances. If no such expression exists, then the algorithm will fail and resort to an alternative scheduling algorithm. In particular, this means that adding proximity dependences may eliminate valid solutions. A typical example where this phenomenon may occur is when some subset of the proximity dependences has no restriction on some parameter, forcing the coefficient of that parameter to be zero, while some other subset forces the dependence distance to depend on that parameter, requiring the same coefficient to be non-zero. When using Feautrier's algorithm, the coincidence and proximity constraints are only taken into account during the extension to a full-dimensional schedule.

An isl_schedule_constraints object can be constructed and manipulated using the following functions.

#include <isl/schedule.h>
__isl_give isl_schedule_constraints *
isl_schedule_constraints_copy(
        __isl_keep isl_schedule_constraints *sc);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_on_domain(
        __isl_take isl_union_set *domain);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_context(
        __isl_take isl_schedule_constraints *sc,
        __isl_take isl_set *context);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_validity(
        __isl_take isl_schedule_constraints *sc,
        __isl_take isl_union_map *validity);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_coincidence(
        __isl_take isl_schedule_constraints *sc,
        __isl_take isl_union_map *coincidence);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_proximity(
        __isl_take isl_schedule_constraints *sc,
        __isl_take isl_union_map *proximity);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_conditional_validity(
        __isl_take isl_schedule_constraints *sc,
        __isl_take isl_union_map *condition,
        __isl_take isl_union_map *validity);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_apply(
        __isl_take isl_schedule_constraints *sc,
        __isl_take isl_union_map *umap);
__isl_null isl_schedule_constraints *
isl_schedule_constraints_free(
        __isl_take isl_schedule_constraints *sc);

The initial isl_schedule_constraints object created by isl_schedule_constraints_on_domain does not impose any constraints. That is, it has an empty set of dependences. The function isl_schedule_constraints_set_context allows the user to specify additional constraints on the parameters that may be assumed to hold during the construction of the schedule. The function isl_schedule_constraints_set_validity replaces the validity dependences, mapping domain elements i to domain elements that should be scheduled after i. The function isl_schedule_constraints_set_coincidence replaces the coincidence dependences, mapping domain elements i to domain elements that should be scheduled together with I, if possible. The function isl_schedule_constraints_set_proximity replaces the proximity dependences, mapping domain elements i to domain elements that should be scheduled either before I or as early as possible after i.

The function isl_schedule_constraints_set_conditional_validity replaces the conditional validity constraints. A conditional validity constraint is only imposed when any of the corresponding conditions is satisfied, i.e., when any of them is non-zero. That is, the scheduler ensures that within each band if the dependence distances over the condition constraints are not all zero then all corresponding conditional validity constraints are respected. A conditional validity constraint corresponds to a condition if the two are adjacent, i.e., if the domain of one relation intersect the range of the other relation. The typical use case of conditional validity constraints is to allow order constraints between live ranges to be violated as long as the live ranges themselves are local to the band. To allow more fine-grained control over which conditions correspond to which conditional validity constraints, the domains and ranges of these relations may include tags. That is, the domains and ranges of those relation may themselves be wrapped relations where the iteration domain appears in the domain of those wrapped relations and the range of the wrapped relations can be arbitrarily chosen by the user. Conditions and conditional validity constraints are only considered adjacent to each other if the entire wrapped relation matches. In particular, a relation with a tag will never be considered adjacent to a relation without a tag.

The function isl_schedule_constraints_apply takes schedule constraints that are defined on some set of domain elements and transforms them to schedule constraints on the elements to which these domain elements are mapped by the given transformation.

An isl_schedule_constraints object can be inspected using the following functions.

#include <isl/schedule.h>
__isl_give isl_union_set *
isl_schedule_constraints_get_domain(
        __isl_keep isl_schedule_constraints *sc);
__isl_give isl_set *isl_schedule_constraints_get_context(
        __isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_validity(
        __isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_coincidence(
        __isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_proximity(
        __isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_conditional_validity(
        __isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_conditional_validity_condition(
        __isl_keep isl_schedule_constraints *sc);

An isl_schedule_constraints object can be read from input using the following functions.

#include <isl/schedule.h>
__isl_give isl_schedule_constraints *
isl_schedule_constraints_read_from_str(isl_ctx *ctx,
        const char *str);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_read_from_file(isl_ctx *ctx,
        FILE *input);

The contents of an isl_schedule_constraints object can be printed using the following functions.

#include <isl/schedule.h>
__isl_give isl_printer *
isl_printer_print_schedule_constraints(
        __isl_take isl_printer *p,
        __isl_keep isl_schedule_constraints *sc);
__isl_give char *isl_schedule_constraints_to_str(
        __isl_keep isl_schedule_constraints *sc);

The following function computes a schedule directly from an iteration domain and validity and proximity dependences and is implemented in terms of the functions described above. The use of isl_union_set_compute_schedule is discouraged.

#include <isl/schedule.h>
__isl_give isl_schedule *isl_union_set_compute_schedule(
        __isl_take isl_union_set *domain,
        __isl_take isl_union_map *validity,
        __isl_take isl_union_map *proximity);

The generated schedule represents a schedule tree. For more information on schedule trees, see "Schedule Trees".

Options

#include <isl/schedule.h>
isl_stat isl_options_set_schedule_max_coefficient(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_max_coefficient(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_max_constant_term(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_max_constant_term(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_serialize_sccs(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_serialize_sccs(isl_ctx *ctx);
isl_stat isl_options_set_schedule_whole_component(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_whole_component(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_maximize_band_depth(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_maximize_band_depth(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_maximize_coincidence(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_maximize_coincidence(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_outer_coincidence(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_outer_coincidence(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_split_scaled(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_split_scaled(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_treat_coalescing(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_treat_coalescing(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_algorithm(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_algorithm(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_carry_self_first(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_carry_self_first(
        isl_ctx *ctx);
isl_stat isl_options_set_schedule_separate_components(
        isl_ctx *ctx, int val);
int isl_options_get_schedule_separate_components(
        isl_ctx *ctx);

AST Generation

This section describes the isl functionality for generating ASTs that visit all the elements in a domain in an order specified by a schedule tree or a schedule map. In case the schedule given as a isl_union_map, an AST is generated that visits all the elements in the domain of the isl_union_map according to the lexicographic order of the corresponding image element(s). If the range of the isl_union_map consists of elements in more than one space, then each of these spaces is handled separately in an arbitrary order. It should be noted that the schedule tree or the image elements in a schedule map only specify the order in which the corresponding domain elements should be visited. No direct relation between the partial schedule values or the image elements on the one hand and the loop iterators in the generated AST on the other hand should be assumed.

Each AST is generated within a build. The initial build simply specifies the constraints on the parameters (if any) and can be created, inspected, copied and freed using the following functions.

#include <isl/ast_build.h>
__isl_give isl_ast_build *isl_ast_build_alloc(
        isl_ctx *ctx);
__isl_give isl_ast_build *isl_ast_build_from_context(
        __isl_take isl_set *set);
__isl_give isl_ast_build *isl_ast_build_copy(
        __isl_keep isl_ast_build *build);
__isl_null isl_ast_build *isl_ast_build_free(
        __isl_take isl_ast_build *build);

The set argument is usually a parameter set with zero or more parameters. In fact, when creating an AST using isl_ast_build_node_from_schedule, this set is required to be a parameter set. An isl_ast_build created using isl_ast_build_alloc does not specify any parameter constraints. More isl_ast_build functions are described in "Nested AST Generation" and "Fine-grained Control over AST Generation". Finally, the AST itself can be constructed using one of the following functions.

#include <isl/ast_build.h>
__isl_give isl_ast_node *isl_ast_build_node_from_schedule(
        __isl_keep isl_ast_build *build,
        __isl_take isl_schedule *schedule);
__isl_give isl_ast_node *
isl_ast_build_node_from_schedule_map(
        __isl_keep isl_ast_build *build,
        __isl_take isl_union_map *schedule);

Inspecting the AST

The basic properties of an AST node can be obtained as follows.

#include <isl/ast.h>
enum isl_ast_node_type isl_ast_node_get_type(
        __isl_keep isl_ast_node *node);

The type of an AST node is one of isl_ast_node_for, isl_ast_node_if, isl_ast_node_block, isl_ast_node_mark or isl_ast_node_user. An isl_ast_node_for represents a for node. An isl_ast_node_if represents an if node. An isl_ast_node_block represents a compound node. An isl_ast_node_mark introduces a mark in the AST. An isl_ast_node_user represents an expression statement. An expression statement typically corresponds to a domain element, i.e., one of the elements that is visited by the AST.

Each type of node has its own additional properties.

#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
        __isl_keep isl_ast_node *node);
__isl_give isl_ast_expr *isl_ast_node_for_get_init(
        __isl_keep isl_ast_node *node);
__isl_give isl_ast_expr *isl_ast_node_for_get_cond(
        __isl_keep isl_ast_node *node);
__isl_give isl_ast_expr *isl_ast_node_for_get_inc(
        __isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_for_get_body(
        __isl_keep isl_ast_node *node);
isl_bool isl_ast_node_for_is_degenerate(
        __isl_keep isl_ast_node *node);

An isl_ast_for is considered degenerate if it is known to execute exactly once.

#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_node_if_get_cond(
        __isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_if_get_then_node(
        __isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_if_get_then(
        __isl_keep isl_ast_node *node);
isl_bool isl_ast_node_if_has_else_node(
        __isl_keep isl_ast_node *node);
isl_bool isl_ast_node_if_has_else(
        __isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_if_get_else_node(
        __isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_if_get_else(
        __isl_keep isl_ast_node *node);

isl_ast_node_if_get_then, isl_ast_node_if_has_else and isl_ast_node_if_get_else are alternative names for isl_ast_node_if_get_then_node, isl_ast_node_if_has_else_node and isl_ast_node_if_get_else_node, respectively.

__isl_give isl_ast_node_list *
isl_ast_node_block_get_children(
        __isl_keep isl_ast_node *node);

__isl_give isl_id *isl_ast_node_mark_get_id(
        __isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_mark_get_node(
        __isl_keep isl_ast_node *node);

isl_ast_node_mark_get_id returns the identifier of the mark. isl_ast_node_mark_get_node returns the child node that is being marked.

#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_node_user_get_expr(
        __isl_keep isl_ast_node *node);

All descendants of a specific node in the AST (including the node itself) can be visited in depth-first pre-order using the following function.

#include <isl/ast.h>
isl_stat isl_ast_node_foreach_descendant_top_down(
        __isl_keep isl_ast_node *node,
        isl_bool (*fn)(__isl_keep isl_ast_node *node,
                void *user), void *user);

The callback function should return isl_bool_true if the children of the given node should be visited and isl_bool_false if they should not. It should return isl_bool_error in case of failure, in which case the entire traversal is aborted.

Each of the returned isl_ast_exprs can in turn be inspected using the following functions.

#include <isl/ast.h>
enum isl_ast_expr_type isl_ast_expr_get_type(
        __isl_keep isl_ast_expr *expr);

The type of an AST expression is one of isl_ast_expr_op, isl_ast_expr_id or isl_ast_expr_int. An isl_ast_expr_op represents the result of an operation. An isl_ast_expr_id represents an identifier. An isl_ast_expr_int represents an integer value.

Each type of expression has its own additional properties.

#include <isl/ast.h>
enum isl_ast_expr_op_type isl_ast_expr_op_get_type(
        __isl_keep isl_ast_expr *expr);
enum isl_ast_expr_op_type isl_ast_expr_get_op_type(
        __isl_keep isl_ast_expr *expr);
isl_size isl_ast_expr_op_get_n_arg(__isl_keep isl_ast_expr *expr);
isl_size isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
__isl_give isl_ast_expr *isl_ast_expr_op_get_arg(
        __isl_keep isl_ast_expr *expr, int pos);
__isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
        __isl_keep isl_ast_expr *expr, int pos);
isl_stat isl_ast_expr_foreach_ast_expr_op_type(
        __isl_keep isl_ast_expr *expr,
        isl_stat (*fn)(enum isl_ast_expr_op_type type,
                void *user), void *user);
isl_stat isl_ast_expr_foreach_ast_op_type(
        __isl_keep isl_ast_expr *expr,
        isl_stat (*fn)(enum isl_ast_expr_op_type type,
                void *user), void *user);
isl_stat isl_ast_node_foreach_ast_expr_op_type(
        __isl_keep isl_ast_node *node,
        isl_stat (*fn)(enum isl_ast_expr_op_type type,
                void *user), void *user);
isl_stat isl_ast_node_foreach_ast_op_type(
        __isl_keep isl_ast_node *node,
        isl_stat (*fn)(enum isl_ast_expr_op_type type,
                void *user), void *user);

isl_ast_expr_op_get_type returns the type of the operation performed. isl_ast_expr_op_get_n_arg returns the number of arguments. isl_ast_expr_get_op_arg returns the specified argument. isl_ast_expr_get_op_type is an alternative name for isl_ast_expr_op_get_type. Similarly, isl_ast_expr_get_op_n_arg is an alternative name for isl_ast_expr_op_get_n_arg and isl_ast_expr_get_op_arg is an alternative name for isl_ast_expr_op_get_arg.

isl_ast_expr_foreach_ast_expr_op_type calls fn for each distinct isl_ast_expr_op_type that appears in expr. isl_ast_expr_foreach_ast_op_type is an alternative name for isl_ast_expr_foreach_ast_expr_op_type. isl_ast_node_foreach_ast_expr_op_type does the same for each distinct isl_ast_expr_op_type that appears in node. isl_ast_node_foreach_ast_op_type is an alternative name for isl_ast_node_foreach_ast_expr_op_type. The operation type is one of the following.

isl_ast_expr_op_and

Logical and of two arguments. Both arguments can be evaluated.

isl_ast_expr_op_and_then

Logical and of two arguments. The second argument can only be evaluated if the first evaluates to true.

isl_ast_expr_op_or

Logical or of two arguments. Both arguments can be evaluated.

isl_ast_expr_op_or_else

Logical or of two arguments. The second argument can only be evaluated if the first evaluates to false.

isl_ast_expr_op_max

Maximum of two or more arguments.

isl_ast_expr_op_min

Minimum of two or more arguments.

isl_ast_expr_op_minus

Change sign.

isl_ast_expr_op_add

Sum of two arguments.

isl_ast_expr_op_sub

Difference of two arguments.

isl_ast_expr_op_mul

Product of two arguments.

isl_ast_expr_op_div

Exact division. That is, the result is known to be an integer.

isl_ast_expr_op_fdiv_q

Result of integer division, rounded towards negative infinity. The divisor is known to be positive.

isl_ast_expr_op_pdiv_q

Result of integer division, where dividend is known to be non-negative. The divisor is known to be positive.

isl_ast_expr_op_pdiv_r

Remainder of integer division, where dividend is known to be non-negative. The divisor is known to be positive.

isl_ast_expr_op_zdiv_r

Equal to zero iff the remainder on integer division is zero. The divisor is known to be positive.

isl_ast_expr_op_cond

Conditional operator defined on three arguments. If the first argument evaluates to true, then the result is equal to the second argument. Otherwise, the result is equal to the third argument. The second and third argument may only be evaluated if the first argument evaluates to true and false, respectively. Corresponds to a ? b : c in C.

isl_ast_expr_op_select

Conditional operator defined on three arguments. If the first argument evaluates to true, then the result is equal to the second argument. Otherwise, the result is equal to the third argument. The second and third argument may be evaluated independently of the value of the first argument. Corresponds to a * b + (1 - a) * c in C.

isl_ast_expr_op_eq

Equality relation.

isl_ast_expr_op_le

Less than or equal relation.

isl_ast_expr_op_lt

Less than relation.

isl_ast_expr_op_ge

Greater than or equal relation.

isl_ast_expr_op_gt

Greater than relation.

isl_ast_expr_op_call

A function call. The number of arguments of the isl_ast_expr is one more than the number of arguments in the function call, the first argument representing the function being called.

isl_ast_expr_op_access

An array access. The number of arguments of the isl_ast_expr is one more than the number of index expressions in the array access, the first argument representing the array being accessed.

isl_ast_expr_op_member

A member access. This operation has two arguments, a structure and the name of the member of the structure being accessed.

isl_ast_expr_op_address_of

The address of its single argument, which is always an array access.

#include <isl/ast.h>
__isl_give isl_id *isl_ast_expr_id_get_id(
        __isl_keep isl_ast_expr *expr);
__isl_give isl_id *isl_ast_expr_get_id(
        __isl_keep isl_ast_expr *expr);

Return the identifier represented by the AST expression. isl_ast_expr_get_id is an alternative name for isl_ast_expr_id_get_id.

#include <isl/ast.h>
__isl_give isl_val *isl_ast_expr_int_get_val(
        __isl_keep isl_ast_expr *expr);
__isl_give isl_val *isl_ast_expr_get_val(
        __isl_keep isl_ast_expr *expr);

Return the integer represented by the AST expression. isl_ast_expr_get_val is an alternative name for isl_ast_expr_int_get_val.

Properties of ASTs

#include <isl/ast.h>
isl_bool isl_ast_expr_is_equal(
        __isl_keep isl_ast_expr *expr1,
        __isl_keep isl_ast_expr *expr2);

Check if two isl_ast_exprs are equal to each other.

Manipulating and printing the AST

AST nodes can be copied and freed using the following functions.

#include <isl/ast.h>
__isl_give isl_ast_node *isl_ast_node_copy(
        __isl_keep isl_ast_node *node);
__isl_null isl_ast_node *isl_ast_node_free(
        __isl_take isl_ast_node *node);

AST expressions can be copied and freed using the following functions.

#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_expr_copy(
        __isl_keep isl_ast_expr *expr);
__isl_null isl_ast_expr *isl_ast_expr_free(
        __isl_take isl_ast_expr *expr);

New AST expressions can be created either directly or within the context of an isl_ast_build.

#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_expr_from_val(
        __isl_take isl_val *v);
__isl_give isl_ast_expr *isl_ast_expr_from_id(
        __isl_take isl_id *id);
__isl_give isl_ast_expr *isl_ast_expr_neg(
        __isl_take isl_ast_expr *expr);
__isl_give isl_ast_expr *isl_ast_expr_address_of(
        __isl_take isl_ast_expr *expr);
__isl_give isl_ast_expr *isl_ast_expr_add(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_sub(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_mul(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_div(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_pdiv_q(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_pdiv_r(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_and(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2)
__isl_give isl_ast_expr *isl_ast_expr_and_then(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2)
__isl_give isl_ast_expr *isl_ast_expr_or(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2)
__isl_give isl_ast_expr *isl_ast_expr_or_else(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2)
__isl_give isl_ast_expr *isl_ast_expr_eq(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_le(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_lt(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_ge(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_gt(
        __isl_take isl_ast_expr *expr1,
        __isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_access(
        __isl_take isl_ast_expr *array,
        __isl_take isl_ast_expr_list *indices);
__isl_give isl_ast_expr *isl_ast_expr_call(
        __isl_take isl_ast_expr *function,
        __isl_take isl_ast_expr_list *arguments);

The function isl_ast_expr_address_of can be applied to an isl_ast_expr of type isl_ast_expr_op_access only. It is meant to represent the address of the isl_ast_expr_access. The second argument of the functions isl_ast_expr_pdiv_q and isl_ast_expr_pdiv_r should always evaluate to a positive number. The function isl_ast_expr_and_then as well as isl_ast_expr_or_else are short-circuit versions of isl_ast_expr_and and isl_ast_expr_or, respectively.

#include <isl/ast_build.h>
__isl_give isl_ast_expr *isl_ast_build_expr_from_set(
        __isl_keep isl_ast_build *build,
        __isl_take isl_set *set);
__isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
        __isl_keep isl_ast_build *build,
        __isl_take isl_pw_aff *pa);
__isl_give isl_ast_expr *
isl_ast_build_access_from_pw_multi_aff(
        __isl_keep isl_ast_build *build,
        __isl_take isl_pw_multi_aff *pma);
__isl_give isl_ast_expr *
isl_ast_build_access_from_multi_pw_aff(
        __isl_keep isl_ast_build *build,
        __isl_take isl_multi_pw_aff *mpa);
__isl_give isl_ast_expr *
isl_ast_build_call_from_pw_multi_aff(
        __isl_keep isl_ast_build *build,
        __isl_take isl_pw_multi_aff *pma);
__isl_give isl_ast_expr *
isl_ast_build_call_from_multi_pw_aff(
        __isl_keep isl_ast_build *build,
        __isl_take isl_multi_pw_aff *mpa);

The set set and the domains of pa, mpa and pma should correspond to the schedule space of build. The tuple id of mpa or pma is used as the array being accessed or the function being called. If the accessed space is a nested relation, then it is taken to represent an access of the member specified by the range of this nested relation of the structure specified by the domain of the nested relation.

The following functions can be used to modify an isl_ast_expr.

#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_expr_set_op_arg(
        __isl_take isl_ast_expr *expr, int pos,
        __isl_take isl_ast_expr *arg);

Replace the argument of expr at position pos by arg.

#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_expr_substitute_ids(
        __isl_take isl_ast_expr *expr,
        __isl_take isl_id_to_ast_expr *id2expr);

The function isl_ast_expr_substitute_ids replaces the subexpressions of expr of type isl_ast_expr_id by the corresponding expression in id2expr, if there is any.

The following function can be used to modify the descendants of a specific node in an AST using a depth-first post-order traversal of those descendants (including the node itself).

#include <isl/ast.h>
__isl_give isl_ast_node *
isl_ast_node_map_descendant_bottom_up(
        __isl_take isl_ast_node *node,
        __isl_give isl_ast_node *(*fn)(
                __isl_take isl_ast_node *node,
                void *user), void *user);

User specified data can be attached to an isl_ast_node and obtained from the same isl_ast_node using the following functions.

#include <isl/ast.h>
__isl_give isl_ast_node *isl_ast_node_set_annotation(
        __isl_take isl_ast_node *node,
        __isl_take isl_id *annotation);
__isl_give isl_id *isl_ast_node_get_annotation(
        __isl_keep isl_ast_node *node);

Basic printing can be performed using the following functions.

#include <isl/ast.h>
__isl_give isl_printer *isl_printer_print_ast_expr(
        __isl_take isl_printer *p,
        __isl_keep isl_ast_expr *expr);
__isl_give isl_printer *isl_printer_print_ast_node(
        __isl_take isl_printer *p,
        __isl_keep isl_ast_node *node);
__isl_give char *isl_ast_expr_to_str(
        __isl_keep isl_ast_expr *expr);
__isl_give char *isl_ast_node_to_str(
        __isl_keep isl_ast_node *node);
__isl_give char *isl_ast_expr_to_C_str(
        __isl_keep isl_ast_expr *expr);
__isl_give char *isl_ast_node_to_C_str(
        __isl_keep isl_ast_node *node);

The functions isl_ast_expr_to_C_str and isl_ast_node_to_C_str are convenience functions that return a string representation of the input in C format.

More advanced printing can be performed using the following functions.

#include <isl/ast.h>
__isl_give isl_printer *
isl_ast_expr_op_type_set_print_name(
        __isl_take isl_printer *p,
        enum isl_ast_expr_op_type type,
        __isl_keep const char *name);
__isl_give isl_printer *isl_ast_op_type_set_print_name(
        __isl_take isl_printer *p,
        enum isl_ast_expr_op_type type,
        __isl_keep const char *name);
isl_stat isl_options_set_ast_print_macro_once(
        isl_ctx *ctx, int val);
int isl_options_get_ast_print_macro_once(isl_ctx *ctx);
__isl_give isl_printer *isl_ast_expr_op_type_print_macro(
        enum isl_ast_expr_op_type type,
        __isl_take isl_printer *p);
__isl_give isl_printer *isl_ast_op_type_print_macro(
        enum isl_ast_expr_op_type type,
        __isl_take isl_printer *p);
__isl_give isl_printer *isl_ast_expr_print_macros(
        __isl_keep isl_ast_expr *expr,
        __isl_take isl_printer *p);
__isl_give isl_printer *isl_ast_node_print_macros(
        __isl_keep isl_ast_node *node,
        __isl_take isl_printer *p);
__isl_give isl_printer *isl_ast_node_print(
        __isl_keep isl_ast_node *node,
        __isl_take isl_printer *p,
        __isl_take isl_ast_print_options *options);
__isl_give isl_printer *isl_ast_node_for_print(
        __isl_keep isl_ast_node *node,
        __isl_take isl_printer *p,
        __isl_take isl_ast_print_options *options);
__isl_give isl_printer *isl_ast_node_if_print(
        __isl_keep isl_ast_node *node,
        __isl_take isl_printer *p,
        __isl_take isl_ast_print_options *options);

While printing an isl_ast_node in ISL_FORMAT_C, isl may print out an AST that makes use of macros such as floord, min and max. The names of these macros may be modified by a call to isl_ast_expr_op_type_set_print_name. The user-specified names are associated to the printer object. isl_ast_op_type_set_print_name is an alternative name for isl_ast_expr_op_type_set_print_name. isl_ast_expr_op_type_print_macro prints out the macro corresponding to a specific isl_ast_expr_op_type. If the print-macro-once option is set, then a given macro definition is only printed once to any given printer object. isl_ast_op_type_print_macro is an alternative name for isl_ast_expr_op_type_print_macro. isl_ast_expr_print_macros scans the isl_ast_expr for subexpressions where these macros would be used and prints out the required macro definitions. Essentially, isl_ast_expr_print_macros calls isl_ast_expr_foreach_ast_expr_op_type with isl_ast_expr_op_type_print_macro as function argument. isl_ast_node_print_macros does the same for expressions in its isl_ast_node argument. isl_ast_node_print, isl_ast_node_for_print and isl_ast_node_if_print print an isl_ast_node in ISL_FORMAT_C, but allow for some extra control through an isl_ast_print_options object. This object can be created using the following functions.

#include <isl/ast.h>
__isl_give isl_ast_print_options *
isl_ast_print_options_alloc(isl_ctx *ctx);
__isl_give isl_ast_print_options *
isl_ast_print_options_copy(
        __isl_keep isl_ast_print_options *options);
__isl_null isl_ast_print_options *
isl_ast_print_options_free(
        __isl_take isl_ast_print_options *options);

__isl_give isl_ast_print_options *
isl_ast_print_options_set_print_user(
        __isl_take isl_ast_print_options *options,
        __isl_give isl_printer *(*print_user)(
                __isl_take isl_printer *p,
                __isl_take isl_ast_print_options *options,
                __isl_keep isl_ast_node *node, void *user),
        void *user);
__isl_give isl_ast_print_options *
isl_ast_print_options_set_print_for(
        __isl_take isl_ast_print_options *options,
        __isl_give isl_printer *(*print_for)(
                __isl_take isl_printer *p,
                __isl_take isl_ast_print_options *options,
                __isl_keep isl_ast_node *node, void *user),
        void *user);

The callback set by isl_ast_print_options_set_print_user is called whenever a node of type isl_ast_node_user needs to be printed. The callback set by isl_ast_print_options_set_print_for is called whenever a node of type isl_ast_node_for needs to be printed. Note that isl_ast_node_for_print will not call the callback set by isl_ast_print_options_set_print_for on the node on which isl_ast_node_for_print is called, but only on nested nodes of type isl_ast_node_for. It is therefore safe to call isl_ast_node_for_print from within the callback set by isl_ast_print_options_set_print_for.

The following option determines the type to be used for iterators while printing the AST.

isl_stat isl_options_set_ast_iterator_type(
        isl_ctx *ctx, const char *val);
const char *isl_options_get_ast_iterator_type(
        isl_ctx *ctx);

The AST printer only prints body nodes of if and for nodes as blocks if these blocks cannot be safely omitted. For example, a for node with one body node will not be surrounded with braces in ISL_FORMAT_C. A block will always be printed by setting the following option.

isl_stat isl_options_set_ast_always_print_block(isl_ctx *ctx,
        int val);
int isl_options_get_ast_always_print_block(isl_ctx *ctx);

Explicit block nodes that appear inside the AST are always printed as blocks. If the block node appears as the outermost node, then it is only printed if the following option is set.

isl_stat isl_options_set_ast_print_outermost_block(
        isl_ctx *ctx, int val);
int isl_options_get_ast_print_outermost_block(
        isl_ctx *ctx);

Options

#include <isl/ast_build.h>
isl_stat isl_options_set_ast_build_atomic_upper_bound(
        isl_ctx *ctx, int val);
int isl_options_get_ast_build_atomic_upper_bound(
        isl_ctx *ctx);
isl_stat isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
        int val);
int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
isl_stat isl_options_set_ast_build_detect_min_max(
        isl_ctx *ctx, int val);
int isl_options_get_ast_build_detect_min_max(
        isl_ctx *ctx);
isl_stat isl_options_set_ast_build_exploit_nested_bounds(
        isl_ctx *ctx, int val);
int isl_options_get_ast_build_exploit_nested_bounds(
        isl_ctx *ctx);
isl_stat isl_options_set_ast_build_group_coscheduled(
        isl_ctx *ctx, int val);
int isl_options_get_ast_build_group_coscheduled(
        isl_ctx *ctx);
isl_stat isl_options_set_ast_build_separation_bounds(
        isl_ctx *ctx, int val);
int isl_options_get_ast_build_separation_bounds(
        isl_ctx *ctx);
isl_stat isl_options_set_ast_build_scale_strides(
        isl_ctx *ctx, int val);
int isl_options_get_ast_build_scale_strides(
        isl_ctx *ctx);
isl_stat isl_options_set_ast_build_allow_else(isl_ctx *ctx,
        int val);
int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
isl_stat isl_options_set_ast_build_allow_or(isl_ctx *ctx,
        int val);
int isl_options_get_ast_build_allow_or(isl_ctx *ctx);

AST Generation Options (Schedule Tree)

In case of AST construction from a schedule tree, the options that control how an AST is created from the individual schedule dimensions are stored in the band nodes of the tree (see "Schedule Trees").

In particular, a schedule dimension can be handled in four different ways, atomic, separate, unroll or the default. This loop AST generation type can be set using isl_schedule_node_band_member_set_ast_loop_type. Alternatively, the first three can be selected by including a one-dimensional element with as value the position of the schedule dimension within the band and as name one of atomic, separate or unroll in the options set by isl_schedule_node_band_set_ast_build_options. Only one of these three may be specified for any given schedule dimension within a band node. If none of these is specified, then the default is used. The meaning of the options is as follows.

atomic

When this option is specified, the AST generator will make sure that a given domain space only appears in a single loop at the specified level.

For example, for the schedule tree

domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
child:
  schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
  options: "{ atomic[x] }"

the following AST will be generated

for (int c0 = 0; c0 <= 10; c0 += 1) {
  if (c0 >= 1)
    b(c0 - 1);
  if (c0 <= 9)
    a(c0);
}

On the other hand, for the schedule tree

domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
child:
  schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
  options: "{ separate[x] }"

the following AST will be generated

{
  a(0);
  for (int c0 = 1; c0 <= 9; c0 += 1) {
    b(c0 - 1);
    a(c0);
  }
  b(9);
}

If neither atomic nor separate is specified, then the AST generator may produce either of these two results or some intermediate form.

separate

When this option is specified, the AST generator will split the domain of the specified schedule dimension into pieces with a fixed set of statements for which instances need to be executed by the iterations in the schedule domain part. This option tends to avoid the generation of guards inside the corresponding loops. See also the atomic option.

unroll

When this option is specified, the AST generator will completely unroll the corresponding schedule dimension. It is the responsibility of the user to ensure that such unrolling is possible. To obtain a partial unrolling, the user should apply an additional strip-mining to the schedule and fully unroll the inner schedule dimension.

The isolate option is a bit more involved. It allows the user to isolate a range of schedule dimension values from smaller and greater values. Additionally, the user may specify a different atomic/separate/unroll choice for the isolated part and the remaining parts. The typical use case of the isolate option is to isolate full tiles from partial tiles. The part that needs to be isolated may depend on outer schedule dimensions. The option therefore needs to be able to reference those outer schedule dimensions. In particular, the space of the isolate option is that of a wrapped map with as domain the flat product of all outer band nodes and as range the space of the current band node. The atomic/separate/unroll choice for the isolated part is determined by an option that lives in an unnamed wrapped space with as domain a zero-dimensional isolate space and as range the regular atomic, separate or unroll space. This option may also be set directly using isl_schedule_node_band_member_set_isolate_ast_loop_type. The atomic/separate/unroll choice for the remaining part is determined by the regular atomic, separate or unroll option. Since the isolate option references outer schedule dimensions, its use in a band node causes any tree containing the node to be considered anchored.

As an example, consider the isolation of full tiles from partial tiles in a tiling of a triangular domain. The original schedule is as follows.

domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
child:
  schedule: "[{ A[i,j] -> [floor(i/10)] }, \
        { A[i,j] -> [floor(j/10)] }, \
        { A[i,j] -> [i] }, { A[i,j] -> [j] }]"

The output is

for (int c0 = 0; c0 <= 10; c0 += 1)
  for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
    for (int c2 = 10 * c0;
         c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
      for (int c3 = 10 * c1;
           c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
        A(c2, c3);

Isolating the full tiles, we have the following input

domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
child:
  schedule: "[{ A[i,j] -> [floor(i/10)] }, \
        { A[i,j] -> [floor(j/10)] }, \
        { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
  options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
        10a+9+10b+9 <= 100 }"

and output

{
  for (int c0 = 0; c0 <= 8; c0 += 1) {
    for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
      for (int c2 = 10 * c0;
           c2 <= 10 * c0 + 9; c2 += 1)
        for (int c3 = 10 * c1;
             c3 <= 10 * c1 + 9; c3 += 1)
          A(c2, c3);
    for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
      for (int c2 = 10 * c0;
           c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
        for (int c3 = 10 * c1;
             c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
          A(c2, c3);
  }
  for (int c0 = 9; c0 <= 10; c0 += 1)
    for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
      for (int c2 = 10 * c0;
           c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
        for (int c3 = 10 * c1;
             c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
          A(c2, c3);
}

We may then additionally unroll the innermost loop of the isolated part

domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
child:
  schedule: "[{ A[i,j] -> [floor(i/10)] }, \
        { A[i,j] -> [floor(j/10)] }, \
        { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
  options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
        10a+9+10b+9 <= 100; [isolate[] -> unroll[3]] }"

to obtain

{
  for (int c0 = 0; c0 <= 8; c0 += 1) {
    for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
      for (int c2 = 10 * c0; c2 <= 10 * c0 + 9; c2 += 1) {
        A(c2, 10 * c1);
        A(c2, 10 * c1 + 1);
        A(c2, 10 * c1 + 2);
        A(c2, 10 * c1 + 3);
        A(c2, 10 * c1 + 4);
        A(c2, 10 * c1 + 5);
        A(c2, 10 * c1 + 6);
        A(c2, 10 * c1 + 7);
        A(c2, 10 * c1 + 8);
        A(c2, 10 * c1 + 9);
      }
    for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
      for (int c2 = 10 * c0;
           c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
        for (int c3 = 10 * c1;
             c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
          A(c2, c3);
  }
  for (int c0 = 9; c0 <= 10; c0 += 1)
    for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
      for (int c2 = 10 * c0;
           c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
        for (int c3 = 10 * c1;
             c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
          A(c2, c3);
}

AST Generation Options (Schedule Map)

In case of AST construction using isl_ast_build_node_from_schedule_map, the options that control how an AST is created from the individual schedule dimensions are stored in the isl_ast_build. They can be set using the following function.

#include <isl/ast_build.h>
__isl_give isl_ast_build *
isl_ast_build_set_options(
        __isl_take isl_ast_build *build,
        __isl_take isl_union_map *options);

The options are encoded in an isl_union_map. The domain of this union relation refers to the schedule domain, i.e., the range of the schedule passed to isl_ast_build_node_from_schedule_map. In the case of nested AST generation (see "Nested AST Generation"), the domain of options should refer to the extra piece of the schedule. That is, it should be equal to the range of the wrapped relation in the range of the schedule. The range of the options can consist of elements in one or more spaces, the names of which determine the effect of the option. The values of the range typically also refer to the schedule dimension to which the option applies, with value 0 representing the outermost schedule dimension. In case of nested AST generation (see "Nested AST Generation"), these values refer to the position of the schedule dimension within the innermost AST generation. The constraints on the domain elements of the option should only refer to this dimension and earlier dimensions. We consider the following spaces.

separation_class

This option has been deprecated. Use the isolate option on schedule trees instead.

This space is a wrapped relation between two one dimensional spaces. The input space represents the schedule dimension to which the option applies and the output space represents the separation class. While constructing a loop corresponding to the specified schedule dimension(s), the AST generator will try to generate separate loops for domain elements that are assigned different classes. If only some of the elements are assigned a class, then those elements that are not assigned any class will be treated as belonging to a class that is separate from the explicitly assigned classes. The typical use case for this option is to separate full tiles from partial tiles. The other options, described below, are applied after the separation into classes.

As an example, consider the separation into full and partial tiles of a tiling of a triangular domain. Take, for example, the domain

{ A[i,j] : 0 <= i,j and i + j <= 100 }

and a tiling into tiles of 10 by 10. The input to the AST generator is then the schedule

{ A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and
                                        i + j <= 100 }

Without any options, the following AST is generated

for (int c0 = 0; c0 <= 10; c0 += 1)
  for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
    for (int c2 = 10 * c0;
         c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
         c2 += 1)
      for (int c3 = 10 * c1;
           c3 <= min(10 * c1 + 9, -c2 + 100);
           c3 += 1)
        A(c2, c3);

Separation into full and partial tiles can be obtained by assigning a class, say 0, to the full tiles. The full tiles are represented by those values of the first and second schedule dimensions for which there are values of the third and fourth dimensions to cover an entire tile. That is, we need to specify the following option

{ [a,b,c,d] -> separation_class[[0]->[0]] :
        exists b': 0 <= 10a,10b' and
                   10a+9+10b'+9 <= 100;
  [a,b,c,d] -> separation_class[[1]->[0]] :
        0 <= 10a,10b and 10a+9+10b+9 <= 100 }

which simplifies to

{ [a, b, c, d] -> separation_class[[1] -> [0]] :
        a >= 0 and b >= 0 and b <= 8 - a;
  [a, b, c, d] -> separation_class[[0] -> [0]] :
        a >= 0 and a <= 8 }

With this option, the generated AST is as follows

{
  for (int c0 = 0; c0 <= 8; c0 += 1) {
    for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
      for (int c2 = 10 * c0;
           c2 <= 10 * c0 + 9; c2 += 1)
        for (int c3 = 10 * c1;
             c3 <= 10 * c1 + 9; c3 += 1)
          A(c2, c3);
    for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
      for (int c2 = 10 * c0;
           c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
           c2 += 1)
        for (int c3 = 10 * c1;
             c3 <= min(-c2 + 100, 10 * c1 + 9);
             c3 += 1)
          A(c2, c3);
  }
  for (int c0 = 9; c0 <= 10; c0 += 1)
    for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
      for (int c2 = 10 * c0;
           c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
           c2 += 1)
        for (int c3 = 10 * c1;
             c3 <= min(10 * c1 + 9, -c2 + 100);
             c3 += 1)
          A(c2, c3);
}
separate

This is a single-dimensional space representing the schedule dimension(s) to which ``separation'' should be applied. Separation tries to split a loop into several pieces if this can avoid the generation of guards inside the loop. See also the atomic option.

atomic

This is a single-dimensional space representing the schedule dimension(s) for which the domains should be considered ``atomic''. That is, the AST generator will make sure that any given domain space will only appear in a single loop at the specified level.

Consider the following schedule

{ a[i] -> [i] : 0 <= i < 10;
  b[i] -> [i+1] : 0 <= i < 10 }

If the following option is specified

{ [i] -> separate[x] }

then the following AST will be generated

{
  a(0);
  for (int c0 = 1; c0 <= 9; c0 += 1) {
    a(c0);
    b(c0 - 1);
  }
  b(9);
}

If, on the other hand, the following option is specified

{ [i] -> atomic[x] }

then the following AST will be generated

for (int c0 = 0; c0 <= 10; c0 += 1) {
  if (c0 <= 9)
    a(c0);
  if (c0 >= 1)
    b(c0 - 1);
}

If neither atomic nor separate is specified, then the AST generator may produce either of these two results or some intermediate form.

unroll

This is a single-dimensional space representing the schedule dimension(s) that should be completely unrolled. To obtain a partial unrolling, the user should apply an additional strip-mining to the schedule and fully unroll the inner loop.

Fine-grained Control over AST Generation

Besides specifying the constraints on the parameters, an isl_ast_build object can be used to control various aspects of the AST generation process. In case of AST construction using isl_ast_build_node_from_schedule_map, the most prominent way of control is through ``options'', as explained above.

Additional control is available through the following functions.

#include <isl/ast_build.h>
__isl_give isl_ast_build *
isl_ast_build_set_iterators(
        __isl_take isl_ast_build *build,
        __isl_take isl_id_list *iterators);

The function isl_ast_build_set_iterators allows the user to specify a list of iterator isl_ids to be used as iterators. If the input schedule is injective, then the number of elements in this list should be as large as the dimension of the schedule space, but no direct correspondence should be assumed between dimensions and elements. If the input schedule is not injective, then an additional number of isl_ids equal to the largest dimension of the input domains may be required. If the number of provided isl_ids is insufficient, then additional names are automatically generated.

#include <isl/ast_build.h>
__isl_give isl_ast_build *
isl_ast_build_set_create_leaf(
        __isl_take isl_ast_build *build,
        __isl_give isl_ast_node *(*fn)(
                __isl_take isl_ast_build *build,
                void *user), void *user);

The isl_ast_build_set_create_leaf function allows for the specification of a callback that should be called whenever the AST generator arrives at an element of the schedule domain. The callback should return an AST node that should be inserted at the corresponding position of the AST. The default action (when the callback is not set) is to continue generating parts of the AST to scan all the domain elements associated to the schedule domain element and to insert user nodes, ``calling'' the domain element, for each of them. The build argument contains the current state of the isl_ast_build. To ease nested AST generation (see "Nested AST Generation"), all control information that is specific to the current AST generation such as the options and the callbacks has been removed from this isl_ast_build. The callback would typically return the result of a nested AST generation or a user defined node created using the following function.

#include <isl/ast.h>
__isl_give isl_ast_node *isl_ast_node_user_from_expr(
        __isl_take isl_ast_expr *expr);
__isl_give isl_ast_node *isl_ast_node_alloc_user(
        __isl_take isl_ast_expr *expr);

isl_ast_node_alloc_user is an alternative name for isl_ast_node_user_from_expr.

In some cases, a single user defined node is not enough, in which case the following function can be used to create a block node from multiple AST nodes.

#include <isl/ast.h>
__isl_give isl_ast_node *isl_ast_node_block_from_children(
        __isl_take isl_ast_node_list *list);

#include <isl/ast_build.h>
__isl_give isl_ast_build *
isl_ast_build_set_at_each_domain(
        __isl_take isl_ast_build *build,
        __isl_give isl_ast_node *(*fn)(
                __isl_take isl_ast_node *node,
                __isl_keep isl_ast_build *build,
                void *user), void *user);
__isl_give isl_ast_build *
isl_ast_build_set_before_each_for(
        __isl_take isl_ast_build *build,
        __isl_give isl_id *(*fn)(
                __isl_keep isl_ast_build *build,
                void *user), void *user);
__isl_give isl_ast_build *
isl_ast_build_set_after_each_for(
        __isl_take isl_ast_build *build,
        __isl_give isl_ast_node *(*fn)(
                __isl_take isl_ast_node *node,
                __isl_keep isl_ast_build *build,
                void *user), void *user);
__isl_give isl_ast_build *
isl_ast_build_set_before_each_mark(
        __isl_take isl_ast_build *build,
        isl_stat (*fn)(__isl_keep isl_id *mark,
                __isl_keep isl_ast_build *build,
                void *user), void *user);
__isl_give isl_ast_build *
isl_ast_build_set_after_each_mark(
        __isl_take isl_ast_build *build,
        __isl_give isl_ast_node *(*fn)(
                __isl_take isl_ast_node *node,
                __isl_keep isl_ast_build *build,
                void *user), void *user);

The callback set by isl_ast_build_set_at_each_domain will be called for each domain AST node. The callbacks set by isl_ast_build_set_before_each_for and isl_ast_build_set_after_each_for will be called for each for AST node. The first will be called in depth-first pre-order, while the second will be called in depth-first post-order. Since isl_ast_build_set_before_each_for is called before the for node is actually constructed, it is only passed an isl_ast_build. The returned isl_id will be added as an annotation (using isl_ast_node_set_annotation) to the constructed for node. In particular, if the user has also specified an after_each_for callback, then the annotation can be retrieved from the node passed to that callback using isl_ast_node_get_annotation. The callbacks set by isl_ast_build_set_before_each_mark and isl_ast_build_set_after_each_mark will be called for each mark AST node that is created, i.e., for each mark schedule node in the input schedule tree. The first will be called in depth-first pre-order, while the second will be called in depth-first post-order. Since the callback set by isl_ast_build_set_before_each_mark is called before the mark AST node is actually constructed, it is passed the identifier of the mark node. All callbacks should NULL (or isl_stat_error) on failure. The given isl_ast_build can be used to create new isl_ast_expr objects using isl_ast_build_expr_from_pw_aff or isl_ast_build_call_from_pw_multi_aff.

Nested AST Generation

isl allows the user to create an AST within the context of another AST. These nested ASTs are created using the same isl_ast_build_node_from_schedule_map function that is used to create the outer AST. The build argument should be an isl_ast_build passed to a callback set by isl_ast_build_set_create_leaf. The space of the range of the schedule argument should refer to this build. In particular, the space should be a wrapped relation and the domain of this wrapped relation should be the same as that of the range of the schedule returned by isl_ast_build_get_schedule below. In practice, the new schedule is typically created by calling isl_union_map_range_product on the old schedule and some extra piece of the schedule. The space of the schedule domain is also available from the isl_ast_build.

#include <isl/ast_build.h>
__isl_give isl_union_map *isl_ast_build_get_schedule(
        __isl_keep isl_ast_build *build);
__isl_give isl_space *isl_ast_build_get_schedule_space(
        __isl_keep isl_ast_build *build);
__isl_give isl_ast_build *isl_ast_build_restrict(
        __isl_take isl_ast_build *build,
        __isl_take isl_set *set);

The isl_ast_build_get_schedule function returns a (partial) schedule for the domains elements for which part of the AST still needs to be generated in the current build. In particular, the domain elements are mapped to those iterations of the loops enclosing the current point of the AST generation inside which the domain elements are executed. No direct correspondence between the input schedule and this schedule should be assumed. The space obtained from isl_ast_build_get_schedule_space can be used to create a set for isl_ast_build_restrict to intersect with the current build. In particular, the set passed to isl_ast_build_restrict can have additional parameters. The ids of the set dimensions in the space returned by isl_ast_build_get_schedule_space correspond to the iterators of the already generated loops. The user should not rely on the ids of the output dimensions of the relations in the union relation returned by isl_ast_build_get_schedule having any particular value.

Applications

Although isl is mainly meant to be used as a library, it also contains some basic applications that use some of the functionality of isl. For applications that take one or more polytopes or polyhedra as input, this input may be specified in either the "isl format" or the "PolyLib format".

isl_polyhedron_sample

isl_polyhedron_sample takes a polyhedron as input and prints an integer element of the polyhedron, if there is any. The first column in the output is the denominator and is always equal to 1. If the polyhedron contains no integer points, then a vector of length zero is printed.

isl_pip

isl_pip takes the same input as the example program from the piplib distribution, i.e., a set of constraints on the parameters, a line containing only -1 and finally a set of constraints on a parametric polyhedron. The coefficients of the parameters appear in the last columns (but before the final constant column). The output is the lexicographic minimum of the parametric polyhedron. As isl currently does not have its own output format, the output is just a dump of the internal state.

isl_polyhedron_minimize

isl_polyhedron_minimize computes the minimum of some linear or affine objective function over the integer points in a polyhedron. If an affine objective function is given, then the constant should appear in the last column.

isl_polytope_scan

Given a polytope, isl_polytope_scan prints all integer points in the polytope.

isl_flow

Given an isl_union_access_info object as input, isl_flow prints out the corresponding dependences, as computed by isl_union_access_info_compute_flow.

isl_codegen

Given either a schedule tree or a sequence consisting of a schedule map, a context set and an options relation, isl_codegen prints out an AST that scans the domain elements of the schedule in the order of their image(s) taking into account the constraints in the context set.

isl_schedule

Given an isl_schedule_constraints object as input, isl_schedule prints out a schedule that satisfies the given constraints.