Assumes divs have been ordered if keep_divs is set. */

Return a list of unions of universe domains, where each element * in the list corresponds to an SCC (or WCC) indexed by node->scc. */

Extract the subgraph of "graph" that consists of the nodes satisfying * "node_pred" and the edges satisfying "edge_pred" and store * the result in "

Extract the coefficients for the variables of "node" from "sol". * * Each schedule coefficient c_i_x is represented as the difference * between two

Return the position of the first inequality constraint in the description * of the basic map represented by "info" that * has position "status" with

Return the first integer division of "bmap" in the range * [first, first + n[ that may depend on any output dimensions and * that has a non-zero coe

Check if the domains and ranges of the basic maps in "map" can * be partitioned, and if so, apply Floyd-Warshall on the elements * of the partition.

* Generate an identity schedule for the computation. * * This identity schedule is an identity relation created from the * time-processor domain.

Generate code for the next level (and all inner levels). * * If "executed" is empty, i.e., no code needs to be generated, * then we return an empty

Look for any (weakly connected) components in the "domain_list" * of domains that share some values of the outer dimensions. * That is, domains in d

Generate code for a single component, after shifting (if any) * has been applied. * * Call generate_shifted_component_tree or generate_shifted_comp

Generate code for a single component, after shifting (if any) * has been applied, in case the schedule was specified as a schedule tree. * In partic

Sort the domains in "domain_list" according to the execution order * at the current depth (for equal values of the outer dimensions), * generate cod

* Return the isl ast associated with this function. */

* Get the number of dimensions of the buffer. */

Retrieve the note identified by "id" from "p". * The note is assumed to exist. */

* Return a unique name of computation; made of the following pattern: * [computation name]@[computation address in memory] */

Replace the subtree that "node" points to by "tree" (which has * a sequence root with two children), except if the parent of "node" * is a sequence

Add the given edge to graph->edge_table[type]. */

Check whether the dependence graph has an edge of the given type * between the given two nodes. */

Check whether the dependence graph has a validity edge * between the given two nodes. * * Conditional validity edges are essentially validity edges

Does "uset" contain any set that satisfies "is"? * "is" is assumed to set its integer argument to 1 if it is satisfied. */

Return the position in ci->index that contains the address of * an inequality that is equal to the k'th inequality of "bmap" * up to the constant te

For each graft in "list", * insert an if node around graft->node testing the condition encoded * in graft->guard, assuming graft->guard involves any

Given a dependence relation R, construct the set of coefficients * of valid constraints for elements in that dependence relation. * In particular, t

Construct an isl_dim_map for mapping constraints on coefficients * for "src" (node i) and "dst" (node j) to the corresponding positions * in graph->

Construct an isl_dim_map for mapping constraints on coefficients * for "node" to the corresponding positions in graph->lp. * "offset" is the offset

Update "change" based on an interchange of the first and the second * basic map. That is, interchange isl_change_drop_first and * isl_change_drop_s

Basic map "i" has an inequality (say "k") that is adjacent * to some inequality of basic map "j". All the other inequalities * are valid for "j".

Check if inequality "ineq" is a bound for basic set "j" or if * it can be relaxed (by increasing the constant term) to become * a bound for that bas

Is "edge" marked as a coincidence edge? */

Is "type" the type of a comparison operator between lists * of affine expressions? */

Is "edge" marked as a local edge? */

Are the "n" coefficients starting at "first" of inequality constraints * "i" and "j" of "bmap" opposite to each other? */

Is "tok" the start of an integer division? */

Add "v" to the constant term of "aff". * * A NaN is unaffected by this operation. */

Add "v" to the constant term of "aff". * * A NaN is unaffected by this operation. */

Are "aff1" and "aff2" obviously equal? * * NaN is not equal to anything, not even to another NaN. */

Return an affine expression that is equal to "val" on * domain local space "ls". */

Simplify the set "set" based on what we know about * the iterators of already generated loops. * * "set" is assumed to live in the (internal) sched

Simplify the piecewise affine expression "aff" based on what we know about * the iterators of already generated loops. * * The domain of "pa" is as

Eliminate unknown divs and divs that depend on the current dimension. * * Note that during the elimination of unknown divs, we may discover * an ex

Construct an isl_ast_expr of type "type" that calls or accesses * the element specified by "mpa". * The first argument is obtained from the output t

Construct an isl_ast_expr of type "type" that calls or accesses * the element specified by "mpa". * The first argument is obtained from the output t

Return a copy of the set of pending constraints. */

Return a copy of the band node that "build" refers to. */

Update "build" for use in a (possibly nested) code generation. That is, * extend "build" from an AST build on some domain O to an AST build * on do

Set the iterators for the next code generation. * * If we still have some iterators left from the previous code generation * (if any) or if iterato

Replace build->single_valued by "sv". */

Add an expression for "v" to expr. */

Create an expression representing the difference of "expr1" and "expr2". */

Record that "guard" needs to be inserted in "graft". */

Create a graft for "node" with no guards and no enforced conditions. */

Record that the grafted tree enforces * "enforced" by intersecting graft->enforced with "enforced". */

Look for shared enforced constraints by all the elements in "list" * on outer loops (with respect to the current depth) and return the result. * *

Create a block node with the given children. */

For each known div d = floor(f/m), add the constraints * * f - m d >= 0 * -(f-(m-1)) + m d >= 0 * * Remove duplicate constraints in case of som

If bmap contains any unknown divs, then compute explicit * expressions for them. However, this computation may be * quite expensive, so first try t

Detect and make explicit all equalities satisfied by the (integer) * points in bmap. */

Drop all constraints in bmap that do not involve any of the dimensions * first to first + n - 1 of the given type. */

Remove divs that are not strictly needed based on the inequality * constraints. * In particular, if a div only occurs positively (or negatively) *

Drop constraints from "bmap" that only involve variables that are * not related to any of the variables marked with a "-1" in "group". * * We const

Construct a basic map mapping the domain of the affine expression * to a one-dimensional range prescribed by the affine expression. */

Construct a basic map mapping the domain the multi-affine expression * to its range, with each dimension in the range equated to the * corresponding

Return a basic map that has the same intersection with "context" as "bmap" * and that is as "simple" as possible. * * The core computation is perfo

Do "bmap1" and "bmap2" have the same parameters? */

Return a relation on "dim" expressing i_pos > o_pos */