Collect the iteration domains of the statements in "scop" * that contain a call expression. */

Collect all dependences from "scop" that are relevant for performing * hybrid tiling on "node" and its child and map them to the schedule * space of

Collect all variable names that are in use in "scop". * In particular, collect all parameters in the context and * all the array names. * Store the

Collect the iteration domains of the statements in "scop", * skipping kill statements. */

Collect the references to all writes in "kernel" that write directly * to global or shared memory, i.e., that are not mapped to private memory. * Ea

For each array in "prog", store the (untagged) order dependences * derived from the array in array->dep_order. * In particular, consider all referen

Collect all references to the given array and store pointers to them * in array->refs. */

Consruct a function that is equal to the time tile of "phase0" * on the domain of "phase0" and equal to the time tile of "phase1" * on the domain of

Complete "grouping" to cover all statement instances in the domain * of grouping->sc. * * In particular, grouping->domain is set to the full set of

Does the index expression "index" of "expr" represent an access * to a single element? * That is, is "index" completely specified? * * If "expr" a

Return the lowest depth between data->kernel_depth and data->thread_depth * at which every array element accessed through "acc" is accessed * by a s

Compute a schedule for the scop "ps". * * First derive the appropriate schedule constraints from the dependences * in "ps" and then compute a sched

Compute the dependences of the program represented by "scop". * Store the computed potential flow dependences * in scop->dep_flow and the reads with

Compute and return the extent of "array", taking into account the set of * accessed elements. * * In particular, the extent in the outer dimension

Compute the potential flow dependences and the potential live in * accesses. * * Both must-writes and must-kills are allowed to kill dependences *

Compute those validity dependences of the program represented by "scop" * that should be unconditionally enforced even when live-range reordering *

Return a description of the full tiles of "phase" at the point * in the original schedule tree where the tiling was applied. * * First construct a

Compute the private and/or shared memory tiles for the array * reference group "group" of array "array". * Return isl_stat_ok on success and isl_sta

Compute a tiling for all the array reference groups in "kernel". */

Construct the basic hexagonal tile shape. * "space" is the 2D space in which the hexagon should be constructed. * h is st-1, with st the tile size i

Compute the live out accesses, i.e., the writes that are * potentially not killed by any kills or any other writes, and * store them in ps->live_out

Compute the dependences of the program represented by "scop" * in case live range reordering is allowed. * * We compute the actual live ranges and

Compute a mapping from the ts-space to the local coordinates * within each tile. In particular, compute * * ts[t, s] -> local_ts[t % (2 S_t), (s +

Compute the set of inner array elements that may have their values * preserved by "prog". In particular, collect the array elements of * arrays tha

Compute the order dependences that prevent the potential live ranges * from overlapping. * * In particular, construct a union of relations * * [R

Compute the offset of phase 1 with respect to phase 0 * in the ts-space ("space"). * In particular, return * * ts[st, s0 + duh] */

Create a set of dimension data->thread_depth + data->n_thread * that equates the residue of the final data->n_thread dimensions * modulo the kernel-

Given a mapping "iterator_map" from the AST schedule to a domain, * return the corresponding mapping from the AST schedule * to the outer kernel->co

Compute an appropriate schedule based on the accesses in * gen->read and gen->write. * * We derive schedule constraints from the dependences in gen

Give the phase_shift ts[S_t, S_0 + floor(d_u h)], * compute a function that applies the shift, i.e., * * ts[t, s] -> ts[t + S_t, s + S_0 + floor(d_

Compute a shift in the space dimension for tiles * at time tile T = floor(t/(2 * S_t)) * such that they align to a multiple of the total space tile

Compute the shift that should be added to the space band * in order to be able to apply rectangular tiling to the space. * Store the shift in phase-

Compute the total size of a tile for the space dimensions, * i.e., those corresponding to the child node * of the input pattern. * If S_0 is the or

Compute the space tiling and store the result in phase->space_tile. * The space tiling is of the form * * [P[t] -> C[s]] -> C[floor((s + space_shif

Collect all write references that require synchronization. * "node" is assumed to point to the kernel node. * Each reference is represented by a uni

Compute the flow dependences and the live_in accesses and store * the results in ps->dep_flow and ps->live_in. * A copy of the flow dependences, tag

Construct a function from tagged iteration domains to the corresponding * untagged iteration domains with as range of the wrapped map in the domain

Return the function * * ts[t, s] -> floor(t/(2 * st)) * * representing the time tile. * "space" is the space ts[t, s]. */

Construct the string "<a>_<b>". */

Construct schedule constraints from the dependences in ps * for the purpose of computing a schedule for a CPU. * * The proximity constraints are se

Construct a unique identifier for a group in "grouping". * * The name is of the form G_n, with n the first value starting at * grouping->group_id t

Construct and return the space local_ts[t, s]. */

Construct a ppcg_ht_phase object, that simply copies * information from "tiling". * That is, the result is defined over the "ts" space and * corres

Construct a mapping from the elements of the original pair of bands * to which tiling was applied that belong to a tile of "phase" * to that tile, p

Construct and return the space ts[t, s]. */

Print code to "p" for copying "array" back from the device to the host * in its entirety. The bounds on the extent of "array" have * been precomput

Print code to "p" for copying "array" from the host to the device * in its entirety. The bounds on the extent of "array" have * been precomputed in

Given a relation "map" between instances of two statements A and B, * does it relate every instance of A (according to the domain of "src") * to eve

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

This function is called for each statement node in the AST * for copying to or from shared/private memory. * Attach a pointer to a ppcg_kernel_stmt

For each array in "prog" of which an element appears in "accessed" and * that is not a read only scalar, create a zero-dimensional universe set * of

This function is called for each instance of a user statement * in the kernel "kernel", identified by "gpu_stmt". * "kernel" may be NULL if we are n

Create a synchronization ppcg_kernel_stmt and * attach it to the node "node" representing the synchronization. */

Close all output files. */

Open the host .cu file and the kernel .hu and .cu files for writing. * Add the necessary includes. */

Print a declaration for the device array corresponding to "array" on "p". */

Check if the access relations of group1 and group2 overlap within * the outermost min(group1->min_depth, group2->min_depth) loops. */

Dereference "expr" by adding an index [0]. * The original "expr" is assumed not to have any indices. * * If "expr" is a member access, then the der

Given an array access "access", check if for any index i there is * a shift a(p) and a stride g such that * * a(p) + i = 0 mod g * * If so, recor

Return the original schedule with all bands marked permutable and * all band members marked coincident based on the coincidence constraints. * The b

Does "domain" consist of a single set with a tuple identifier * corresponding to a synchronization for "kernel"? */

Eliminate dead code from ps->domain. * * In particular, intersect both ps->domain and the domain of * ps->schedule with the (parts of) iteration *

Does "expr" contain any call expressions? */

Compute bounds on the host array "pa" based on the corresponding * accessed elements in "arrays" * and collect all references to the array. * Store

Compute the effective block size as a list of the sizes in each dimension * and store the sizes in kernel->block_dim. * * The block size specified

Extract the set of parameter values and outer schedule dimensions * for which any statement instance * in the kernel inserted at "node" needs to be

Compute the size of a fixed bounding box around the origin and "set", * where "set" is assumed to contain only non-negative elements, * and store th

Compute the effective grid size as a list of the sizes in each dimension. * * The grid size specified by the user or set by default * in read_grid_

Return an array of "n" elements with information extracted from * the "n" children of "node" starting at "first", all of which * are known to be fil

Return (the universe spaces of) the arrays that are declared * inside the scop corresponding to "prog" and for which all * potential writes inside t

Given a tagged access relation to a single array "tagged", extract it * as a map, taking into account that the input may be empty. * If the access r

Return an array of gpu_stmt representing the statements in "scop". * Do not collect array accesses for statements that have been killed. */

Return the gpu_stmt_access in the list "accesses" that corresponds * to "ref_id". */

Return the index of the array called "name" in the list of arrays. */

Return a pointer to the gpu_array_ref_group in "local" * that contains the reference "access". * Return NULL if no such group can be found. */

Find the element in gen->stmt that has the given "id". * Return NULL if no such gpu_stmt can be found. */

Find the element in scop->stmts that has the given "id". */

Generate CUDA code for "scop" and print it to "p". * After generating an AST for the transformed scop as explained below, * we call "gen->print" to

Generate CPU code for "scop" and print it to "p". * * First obtain a schedule for "scop" and then print code for "scop" * using that schedule. */

Use isl to generate code for both the host and the device * from "schedule". * The device code is marked by "kernel" mark nodes in the schedule tree

Transform the code in the file called "input" by replacing * all scops by corresponding CPU code and write the results to a file * called "output".

Transform the code in the file called "input" by replacing * all scops by corresponding CUDA code. * The names of the output files are derived from

Return an isl_id called "prefix%d", with "%d" set to "i". * If an isl_id with such a name already appears among the variable names * of "scop", then

Transform the code in the file called "input" by replacing * all scops by corresponding OpenCL code. * The host code is written to "output" or a nam

Given a set or sequence node, return the union of the filters of * the direct subtrees that do not contain any suitably permutable bands * (accordin

Given a set or sequence node, return the union of the filters of * the initial direct subtrees that do not contain any suitably permutable * bands (

Return the coincidence constraints between pairs of instances * that are scheduled together by the ancestors of "node". * That is, select those coin

Derive the output file name from the input file name. * 'input' is the entire path of the input file. The output * is the file name plus the additio

Short-hand for retrieving the prefix schedule at "node" * in the form of an isl_multi_union_pw_aff. */

Obtain a schedule for the scop, by reading it from * a file, by computing one or by determining the properties * of the original schedule. */

Compute a schedule based on the dependences in "ps" and * tile it if requested by the user. */

Compute a tiling for the array reference group "group". * * The tiling is of the form * * { [D[i] -> A[a]] -> T[t] } * * where D represents the

Does the tile associated to "group" require unrolling of the schedule * dimensions mapped to threads? * Note that this can only happen for private t

Group references of all arrays in "kernel". * "node" points to the kernel mark. * The mapping to shared memory in computed at the "shared" mark. *