Return the effective gpu_array_tile associated to "group" or * NULL if there is no such gpu_array_tile. */

Move up the tree underneath the "kernel" mark until * the "kernel" mark is reached. */

If group->n_ref == 1, then group->refs was set by * populate_array_references to point directly into * group->array->refs and should not be freed.

Free "bounds" along with all its fields. */

Is "array" a read-only scalar? */

Should this array reference group be mapped to private, shared or global * memory? * If we have computed both a private and a shared tile, then * t

Mark all dimensions in the band node "node" to be of "type". */

Does "array" need to be allocated on the device? * If it is a read-only scalar, then it will be passed as an argument * to the kernel and therefore

Move down the branch between "kernel" and "thread" until * the "thread" mark is reached, where the branch containing the "thread" * mark is identifi

Print the required macros for "expr". */

Return a list of "n" isl_ids of the form "prefix%d". * If an isl_id with such a name already appears among the variable names * of "scop", then adju

Move to the only child of "node" that has the "thread" mark as descendant, * where the branch containing this mark is identified by the domain elemen

Is "node" a mark node with an identifier called "thread"? */

Print an expression for the size of "array" in bytes. */

Check if a gpu array is a scalar. A scalar is a value that is not stored * as an array or through a pointer reference, but as a single data element.

Free "phase" along with all its fields. */

Expand the domain of the schedule "s" by plugging in * the contraction "contraction" and return the result. */

Compute the size of the tile specified by "tile" * in number of elements and return the result. */

Print the required macros for the GPU AST "node" to "p", * including those needed for the user statements inside the AST. */

Move down from the "kernel" mark (or at least a node with schedule * depth smaller than or equal to "depth") to a band node at schedule * depth "dep

Does "node" point to a filter selecting a synchronization statement * for "kernel"? */

Build an access AST expression from "size" using "build". * "size" does not have a domain, but "build" may have a proper schedule space. * First mod

Return the domain of hybrid tiling phase "phase". */

Remove a reference to "tile" and free "tile" along with all its fields * as soon as the reference count drops to zero. */

Set the names of the macros that may appear in a printed isl AST. */

Compute the size of a bounding box around the origin and "set", * where "set" is assumed to contain only non-negative elements. * In particular, com

Compare the prefix of "s" to "prefix" up to the length of "prefix". */

Check if all the fields of "phase" are valid, freeing "phase" * if they are not. */

Compute the private and/or shared memory tiles for the array * reference group "group" of array "array" and set the tile depth. * Return 0 on succes

Construct an isl_multi_val for use as tile sizes for tiling "node" * from the elements in "tile_size". */

Given a union map { kernel[i] -> *[...] }, * return the range in the space called "type" for the kernel with * sequence number "id". */

Return the name of the outer array (of structs) accessed by "access". */

Insert an extension on top of "node" that puts a synchronization node * for "kernel" after "node" unless there already is * such a synchronization n

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

Is "node" a mark node with an identifier called "name"? */

Is "node" a mark node with an identifier called "shared"? */

Open the file called "name" for writing or print an error message. */

Print a call to the OpenCL clSetKernelArg() function which sets * the arguments of the kernel. arg_name and arg_index are the name and the * index

Compute a schedule on the domain of "sc" that respects the schedule * constraints in "sc", without trying to combine groups of statements. */

Copy the base name of "input" to "name" and return its length. * "name" is not NULL terminated. * * In particular, remove all leading directory com

Clear all memory allocated by "grouping". */

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

Does "kernel" need to be passed an argument corresponding to array "i"? * * The argument is only needed if the kernel accesses this device memory.

Given a singleton set, extract the first (at most *len) elements * of the single integer tuple into *sizes and update *len if needed. * * If "set"

Given an access relation "access" from one or more array reference groups, * remove those reads if ("read" is 1) or writes (if "read" is 0) * that a

Return constraints on the domain elements that equate a sequence of * parameters called "names", to the partial schedule * of "node" modulo the inte

Add the map { kernel[id] -> type[sizes] } to gen->used_sizes, * if the option debug->dump_sizes is set. */

Replace the partial schedule S of the band node "node" by * * floor(S/f) * * or * * f * floor(S/f) * * if scale_tile_loops is set, with f the

If the band node "node" has more than "n" members, then split off * the first "n" of them. */

Does the subtree rooted at "node" have any suitably permutable band nodes? * That is, does it have any nodes that are permutable and that * have a l

Given an access relation in terms of at least data->thread_depth initial * dimensions of the computed schedule, check if it is bijective for * fixed

Return the set of outer array elements accessed by * by the statement instances in "domain" in "prog". * The instances in "domain" are those that ap

Add "len" parameters p[i] with identifiers "ids" and intersect "set" * with * * { : 0 <= p[i] < size[i] } * * or an overapproximation. */

Check whether the array reference group "group" is mapped to * private or shared memory and, if so, * add copy statements to the schedule tree of "n

If any writes in "group" require synchronization, then make sure * that there is a synchronization node for "kernel" after the node * following "nod

Return a read ("read" is 1) or write access relation for "group" * with those accesses removed that are only needed to communicate data * within the

Check if we can find a memory tile for the given array * based on the given accesses, and if so, put the results in "tile". * * We project the acce

Check that "node" satisfies the input pattern for hybrid tiling. * Error out if it does not. */

Collect the iteration domains of the statements in "scop" that * satisfy "pred". */

Compute the tagged flow dependences and the live_in accesses and store * the results in ps->tagged_dep_flow and ps->live_in. * * Both must-writes a

Compute the number of outer schedule tile dimensions that affect * the offset of "tile". * If there is no such dimension, then return the index * o

Construct schedule constraints from the dependences in prog->scop and * the array order dependences in prog->array_order. * * If live range reorder

Copy "array" from the host to the device (to_host = 0) or * back from the device to the host (to_host = 1). */

Create a graft for copying arrays to or from the device, * whenever the size of the array is strictly positive. * Each statement is called "<prefix>

Given an array reference group "group", create a mapping * * read[D -> A] -> [D -> A] * * if "read" is set or * * write[D -> A] -> [D -> A] *

Create a union set containing a single set with a tuple identifier * called "syncX" and user pointer equal to "kernel". */

Mark all variables that are accessed by the statement instances in "domain" * and that are local to "prog" as requiring a declaration in the host cod

Compute ps->dep_flow from ps->tagged_dep_flow * by projecting out the reference tags. */

Given a set of local reaching domain elements "domain", * expand them to the corresponding leaf domain elements using "contraction" * and insert the

Extract the input schedule from "node", i.e., the product * of the partial schedules of the parent and child nodes * in the input pattern. */

Given a filter node that is the child of a set or sequence node, * restrict data->local_flow to refer only to those elements * in the filter of the

Transform the code in the file called "input" by replacing * all scops by corresponding GPU code and write the results to "out". */

Return the ppcg_macros object that holds the currently active * macro definitions in "p". * If "p" has a note with macro definitions, then return th

Given a set or sequence node, return the union the filters of either all * (if "only_initial" is not set) or the initial (if "only_initial" is set)

Can "array" be mapped to private memory? * That is, is it only accessed as individual elements with * constant index expressions? */

Print the call of an array argument. */

Print the declaration of an array argument. * "memory_space" allows to specify a memory space prefix. */

Return the set of parameter values for which the array has a positive * size in all dimensions. * If the sizes are only valid for some parameter val

Return the union of all read (read = 1) and/or write (write = 1) * access relations in the group. */

Print the name of the local copy of a given group of array references. */

Create a gpu_array_tile for an array of dimension "n_index". */

Create a ppcg_kernel representing the domain instances that reach "node" * and insert a mark node pointing to the ppcg_kernel before "node". * The b

Linearize the index expression "expr" based on the array bounds * of "array". * * That is, transform expression * * A[i_0][i_1]...[i_n] * * to

Print declarations to "p" for arrays that are local to "prog" * but that are used on the host and therefore require a declaration. */

Print the definitions of all types prog->scop that have not been * printed before (according to "types") on "p". * Extend the list of printed types

Is "id" the identifier of a synchronization statement inside "kernel"? * That is, does its name start with "sync" and does it point to "kernel"? */

Move down the branch between "kernel" and "thread" until * the "shared" mark is reached, where the branch containing the "shared" * mark is identifi

Move left in the sequence on top of "node" to a synchronization node * for "kernel". * If "node" itself contains a synchronization node preceding *

If two groups have overlapping access relations (within the outer * depth loops) and if one of them involves a write, * then merge the two groups in

Look for any pairs of consecutive leaves among the "n" children of "node" * starting at "first" that should be merged together. * Store the results