Collect the references to all writes in "group". * Each reference is represented by a universe set in a space * * [S[i,j] -> R[]] * * with S[i,j]

If two groups have overlapping access relations (as determined by * the "overlap" function) and if one of them involves a write, * then merge the tw

Does "node" satisfy the properties of the inner node in the input * pattern for hybrid tiling? * That is, is it a band node with only coincident mem

Does "node" satisfy the properties of the outer node in the input * pattern for hybrid tiling? * That is, is it a band node with a single member? *

Is "node" part of a sequence with a previous synchronization statement * for "kernel"? * That is, is the parent of "node" a filter such that there i

Does the subtree rooted at "node" (which is a band node) contain * any synchronization statement for "kernel" that follows * the core computation of

Given a branch "node" that contains a sequence node with two phases * of hybrid tiling as input, call "fn" on each of the two phase marker * nodes.

Insert a mark node at "node" holding a pointer to "phase". */

Insert a band node for performing the space tiling for "phase" at "node". * In particular, insert a band node with partial schedule * * [P[t] -> C[

Insert (or extend) an extension on top of "node" that puts * a synchronization node for "kernel" afater "node". * Return a pointer to the original n

Is "node" a candidate for mapping to block and thread identifiers? * In particular, is it permutable with at least one coincident dimension? * Alter

Can "node" be tiled and then mapped to block and thread identifiers? * That is, is it permutable with at least one coincident dimension? */

Does "id" contain a pointer to a ppcg_ht_phase? * That is, is it called "phase"? */

Combine the given two groups into a single group, containing * the references of both groups. */

Combine the given two groups into a single group and free * the original two groups. */

Given a set of dependence distance vectors "dist", compute * pair of non-negative bounds min and max such that * * d_pos >= -min d_0 * and * d_po

Return the number of outer band members of the band node "node" * that are marked coincident. */

Construct a map from domain_space to domain_space that increments * the dimension at position "pos" and leaves all other dimensions * constant. */

Return the OpenCL error string for a given error number. */

Write text to a file and escape some special characters that would break a * C string. */

Given a parameter space "space", create a set of dimension "len" * of which the dimensions starting at "first" are equated to * freshly created para

Compute a schedule on the domain of "sc" that respects the schedule * constraints in "sc". * * "schedule" is a known correct schedule that is used

Obtain a schedule, either by reading it form a file * or by computing it using "compute". * Also take care of saving the computed schedule and/or *

Return the upper bound on the relative dependence distances * in the first space dimension. */

Can the bounds on relative dependence distances recorded in "bounds" * be used to perform hybrid tiling? * In particular, have appropriate lower and

Replace the lower bound on the relative dependence distances * in space dimension "pos" by "lower". */

Return the space of the pair of band nodes that form the input * to the hybrid tiling of which "phase" is a phase. * In particular, return the space

Construct a representation for one of the two phase for hybrid tiling * "tiling". If "shift" is not set, then the phase is constructed * directly f

Return the space of the pair of band nodes that form the input * to the hybrid tiling. * In particular, return the space [P -> C], where P is the sp

Print a copy statement. * * A read copy statement is printed as * * local = global; * * while a write copy statement is printed as * * global

Construct an isl_multi_val living in "space" with values specified * by "list". "list" is assumed to have at least as many entries * as the set dim

Set defaults that depend on the target. * In particular, set --schedule-outer-coincidence iff target is a GPU. */

Print the required macro definitions for the body of a statement in which * the access expressions are replaced by the isl_ast_expr objects * in "re

Print a declaration for an array with element type "base_type" and * size "size" to "p". */

Print declarations for the arrays in "scop" that are declared * and exposed to the code after the scop. */

Print a macro definition for "type" to "p". * If GNU extensions are allowed, then print a specialized definition * for isl_ast_op_min and isl_ast_op

Print the required macros for "node". */

Does "scop" refer to any arrays that are declared, but not * exposed to the code after the scop? */

Transform the C source file "input" by rewriting each scop * through a call to "transform". * The transformed C code is written to "out". * * This

Return the prefix schedule at "node" as a relation * between domain elements and schedule dimensions after detecting * equalities in this relation.

Generate CPU code for the scop "ps" using "schedule" and * print the corresponding C code to "p", including variable declarations. */

Print declarations for the arrays in "scop" that are declared * and that are exposed (if exposed == 1) or not exposed (if exposed == 0). */

Print a list of iterators of type "type" with names "ids" to "p". * Each iterator is assigned the corresponding opencl identifier returned * by the

Print a list of iterators of type "type" with names "ids" to "out". * Each iterator is assigned one of the cuda identifiers in cuda_dims. * In parti

Print the arguments to a kernel declaration or call. If "types" is set, * then print a declaration (including the types of the arguments). * * The

Print the header of the given kernel. */

Print a macro definition "def" for the macro "name" to "p", * unless such a macro definition has been printed to "p" before. * "note_name" is used a

Pull back "phase" over "ma". * That is, take a phase defined over the range of "ma" and * turn it into a phase defined over the domain of "ma". */

Extract user specified "tile" sizes from the "sizes" command line option, * defaulting to option->tile_size in each dimension. * *tile_len contains

Remove those flow dependences from data->may_persist_flow * that flow between elements of "domain" within the same iteration * of all outer band nod

Set array->n_group and array->groups to n and groups. * * Additionally, set the "nr" field of each group. */

Print an access to the element in the global memory copy * described by "stmt". The index of the copy is recorded in * stmt->index as an access to

Print an access to the element in the private/shared memory copy * described by "stmt". The index of the copy is recorded in * stmt->local_index as

Adjust the fields of "tile" to reflect the new input dimension "depth". * The dimension beyond "depth" are assumed not to affect the tile, * so they

Mark the given band node "node" for unrolling by the AST generator and * then sink it to the leaves of the schedule tree. * All dimensions of "node"

Does * * s0 > delta + 2 * {delta * h} - 1 * * hold? */

Given a set of wrapped references "ref", return the corresponding * access relations based on the tagged access relations "tagged". * * The element

Check if the given access is coalesced (or if there is no point * in trying to coalesce the access by mapping the array to shared memory). * That is

Does "expr" access a single, fixed element (independently of the statement * instance)? * That is, does it have a completely specified constant inde

Add parameters p[i] with identifiers "ids" to "set", * with bounds to 0 <= p[i] < size[i]. */

For each array reference group that is mapped to private or shared memory, * add copy statements to the schedule tree of "node" * for reading from g

Add copy statements to the schedule tree of "node" * for reading from global memory to private memory (if "read" is set) or * for writing back from

Add copy statements to the schedule tree of "node" * for reading from global memory to shared memory (if "read" is set) or * for writing back from s

Extend "grouping" with groups corresponding to merged * leaves in the list of potentially merged leaves "leaves". * * The "list" field of each elem

Add nodes for initializing ("init_device") and clearing ("clear_device") * the device before and after "node". */

Given a filter node "node", collect the filters on all following siblings * (which are also filter nodes), add them to "filters" and return the resul

Add parameters with identifiers "ids" to "set". */

Given a filter node "node", collect the filters on all preceding siblings * (which are also filter nodes), add them to "filters" and return the resul

Insert a synchronization node in the schedule tree of "node" * after the core computation of "kernel" at the level of the band * that is mapped to t

Add nodes for copying outer arrays in and out of the device * before and after the subtree "node", which contains one or more kernels. * "domain" co

Are all members of the band node "node" coincident? */

Allocate an ast_node_info structure and initialize it with default values. */

Allocate a device array for "array'. * * Emit a max-expression to ensure the device array can contain at least one * element if the array's positiv

Was the definition of "type" printed before? * That is, does its name appear in the list of printed types "types"? */

Return true if there is a double array in prog->array or * if any of the types in prog->scop involve any doubles. * To check the latter condition, w

Are there any direct writes to global memory that require * synchronization? */

Is there any write access in "group" that requires synchronization * on a write to global memory? * We currently take into account all writes that w

Replace any reference to an array element in the range of "copy" * by a reference to all array elements (defined by the extent of the array). */

Return the extent of "array", recomputed from the bounds. * The recomputed extent may be simpler than the original extent. */

Check if the current scheduling dimension is parallel. * * We check for parallelism by verifying that the loop does not carry any * dependences. *

Mark all dimensions in the current band node atomic. */

Mark "node" atomic, if it is a band node. * Do the same for all ancestors. * Return a pointer to "node" (in the updated schedule tree). */

For each member in the band node "node", determine whether * it is coincident with respect to the outer nodes and mark * it accordingly. * * That

If the band node "node" has exactly one member then mark it permutable. */

Build AST expressions for the device array sizes of all arrays in "prog" * that require allocation on the device using "build", as well as * for the

Build access AST expressions for the effective grid size and * the localized array sizes using "build". */

Build an access AST expression for the effective grid size using "build". * Store the result in kernel->grid_size_expr. */

Build access AST expressions for the localized array sizes using "build". * Store the result in local->bound_expr. * Only do this for arrays for whi

For each array in the input program that can be mapped to private memory, * check if there are any order dependences active inside the current kernel

Check consistency of options. * * Return -1 on error. */

Given an access relation in terms of the data->thread_depth initial * dimensions of the computed schedule and the thread identifiers * (as parameter

If max_shared_memory is not set to infinity (-1), then make * sure that the total amount of shared memory required by the * array reference groups m

Check that the tile will be wide enough in the first space * dimension, i.e., the base of the hexagon. This ensures that * neighboring hexagons in

chemv - complex hermitian matrix-vector multiplication * The function body was taken from a VOBLA-generated BLAS library. */

Clear all memory allocated by "build_info". */

Print code for clearing the device after execution of the transformed code. * In particular, free the memory that was allocated on the device. */

Print code for clearing the device after execution of the transformed code. * In particular, free the memory that was allocated on the device. */

Construct a gpu_array_info for each array referenced by prog->scop and * collect them in prog->array. * * The sizes are based on the extents and th