Apply hybrid tiling on "node" and its parent based on the (valid) * bounds on the relative dependence distances "bounds" and * the tile sizes in "ti

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

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

Insert a "shared" mark in front of the "thread" mark * provided the linear branch between "node" and the "thread" mark * does not contain such a "sh

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

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

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

Group array references that should be considered together when * deciding whether to access them from private, shared or global memory. * Return -1

Given an initial grouping of array references and shared memory tiles * for each group that allows for a shared memory tile, merge two groups * if b

Construct a contraction from "prefix" and "domain" for a new group * in "grouping". * * The values of the prefix schedule "prefix" are used as inst

If two groups have overlapping access relations (within the innermost * loop) and if one of them involves a write, then merge the two groups * into

Group the domain elements into a single space, named kernelX, * with X the kernel sequence number "kernel_id". */

Return the union of all tagged access relations in the group. */

Return a map from the first group->shared_tile->depth dimensions * of the computed schedule to the array tile in * global memory that corresponds to

Does "schedule" contain any permutable band with at least one coincident * member? */

Have all domain elements been filtered out before reaching * the "node" position in the schedule tree? */

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

Construct the lower constraint of the hexagonal tile, i.e., * * a <= 2h+1 * -a + 2h+1 >= 0 * * This constraint corresponds to (7) in * "Hybrid H

Construct the lower left constraint of the hexagonal tile, i.e., * * du a - b <= (2h+1) du - duh * -du a + b + (2h+1) du - duh >= 0 * * where duh

Construct the lower right constraint of the hexagonal tile, i.e., * * dl a + b <= (2h+1) dl + duh + (s0-1) * -dl a - b + (2h+1) dl + duh + (s0-1) >

Construct the uppper constraint of the hexagonal tile, i.e., * * a >= 0 * * This constraint corresponds to (13) in * "Hybrid Hexagonal/Classical

Construct the upper left constraint of the hexagonal tile, i.e., * * dl a + b >= h dl - (d - 1)/d with d = den(dl) * dl a + b - h dl + (d - 1)/d

Construct the upper right constraint of the hexagonal tile, i.e., * * du a - b >= du h - duh - (s0-1) - dlh - (d - 1)/d with d = den(du) * du a - b

Given a branch "node" that contains a sequence node with two phases * of hybrid tiling as input, remove the two phase marker nodes. * * That is, th

Initialize the fields of "build_info". * * Initially, the AST generation is not inside any parallel for loop. * * The contraction of the entire sc

Print code for initializing the device for execution of the transformed * code. This includes declaring locally defined variables as well as * decl

Print code for initializing the device for execution of the transformed * code. This includes declaring locally defined variables as well as * decl

Insert a context node at "node" introducing the block and thread * identifiers along with their bounds, which are stored in kernel->grid_size * and

Insert a zero-dimensional permutable band at "node". */

Insert a guard that eliminates kernel launches where the kernel * obviously does not have any work to do. * * In particular, eliminate kernel launc

Make sure that code for the statements in "filters" that * copy arrays to or from the device is only generated when * the size of the corresponding

Insert a mark node with identifier "shared" in front of "node". */

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

Given an array, check whether its positive size guard expression is * trivial. */

Is "node" the outermost node in its branch that can be tiled * and then mapped to block and thread identifiers? * If there are no such nodes in the

Is the array "array" being extracted a read-only scalar? * * That is, is "array" a scalar that is never possibly written to. * An array containing

Has statement "stmt" been killed from "scop"? * That is, is the instance set of "scop" free from any * instances of "stmt"? */

If "node" points to a set node, then separate its children * into subtrees that have suitably permutable bands and * those that do not. * Adjust th

Combine all groups in "groups" into a single group and return * the new number of groups (1 or 0 if there were no groups to start with). */

Does any array reference group mapping require the band that is mapped * to threads to be unrolled? */

Take a "phase" defined over the ts-space and plug in the projection * from the input schedule space to the ts-space. * The result is then defined ov

Given a constraint of the form * * a i_0 + b i_1 >= 0 * or * a i_0 + b i_1 = 0 * * use it to update one or both of the non-negative bounds * in

Load and return a schedule from a file called "filename". */

Replace the host schedule dimensions in the access relation "access" * by parameters, so that they are treated as fixed when checking for reuse * (w

The sizes of the arrays on the host that have been computed by * extract_array_info may depend on the parameters. Use the extra * constraints on th

Update "schedule" for mapping to a GPU device. * * In particular, insert a context node, create kernels for * each outermost tilable band and intro

Mark all arrays of "kernel" that have an array reference group * that is not mapped to private or shared memory as * accessing the corresponding glo

Insert "kernel" marks that point to a ppcg_kernel structure * in front of all outermost tilable band that (by construction) * have at least one para

Mark a for node openmp parallel, if it is the outermost parallel for node. */

Keep track of the fact that the macro definition corresponding * to "note_name" has been printed to "p" by attaching a note with * that name. The v

Given a relation "map" between instances of two statements A and B, * are pairs of related instances executed together in the input schedule? * That

Merge pairs of consecutive leaves in "leaves" taking into account * the intersection of validity and proximity schedule constraints "dep". * * If a

Merge the leaves at position "pos" and "pos + 1" in "leaves". */

Assuming "node" is a filter node, does it correspond to the branch * that contains the "thread" mark, i.e., does it contain any elements * in "core"

Determine the set of array elements that may need to be perserved * by a kernel constructed from the subtree at "node". * This includes the set of a

Is "array" only accessed as individual, fixed elements? * That is, does each access to "array" access a single, fixed element? */

Allocate accessed device arrays. */

Create an OpenCL program from a string and compile it. */

Close all output files. Write the kernel contents to the kernel file before * closing it. * * Return 0 on success and -1 on failure. */

Prints a #pragma to enable support for double floating-point * precision. OpenCL 1.0 adds support for double precision floating-point as * an optio

Open the host .c file and the kernel .h and .cl files for writing. * Their names are derived from info->output (or info->input if * the user did not

Write text to a file as a C string literal. * * This function also prints any characters after the last newline, although * normally the input stri

Print the block sizes as a list of the sizes in each * dimension. */

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 call to barrier() which is a sync statement. * All work-items in a work-group executing the kernel on a processor must * execute the barrier

Print a list that represents the total number of work items. The list is * constructed by performing an element-wise multiplication of the block siz

This function prints the i'th block size multiplied by the i'th grid size, * where i (a parameter to this function) is one of the possible dimensions

Free the accessed device arrays. */

Set the arguments of the OpenCL kernel by printing a call to the OpenCL * clSetKernelArg() function for each kernel argument. */

Create an OpenCL device, context, command queue and build the kernel. * input is the name of the input file provided to ppcg. */

Write the code that we have accumulated in the kernel isl_printer to the * kernel.cl file. If the opencl_embed_kernel_code option has been set, prin

Return an isl_multi_aff, with as elements the parameters in "space" * that have the names specified by the elements in "names". * If (some of) these

Equate the dimensions of "set" starting at "first" to * freshly created parameters with identifiers "ids". * The number of equated dimensions is equ

Construct a linked list of gpu_stmt_access objects, * one for each access expression in the statement body. * "any_to_outer" maps all intermediate a

Align the parameters of the elements of "phase" to those of "space". */

Fill up the groups array with singleton groups, i.e., one group * per reference, initializing the array, access, write, n_ref and refs fields. * In

Given a multi affine expression "mpa" without domain, modify it to have * the schedule space of "build" as domain. * * If the schedule space of "bu

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

Compute the intersection of the proximity and validity dependences * in grouping->sc and store the result in grouping->dep, unless * this intersecti

Free all memory allocated for "leaves". */

Create a ppcg_ht_bounds object for a band living in "space". * The bounds are initialized to NaN. */

Construct a hybrid tiling description from bounds on the dependence * distances "bounds". * "input_node" points to the original parent node. * "inp

Given valid bounds on the relative dependence distances for * the pair of nested nodes that "node" point to, as well as sufficiently * wide tile siz

Replace the upper bound on the relative dependence distances * in the first space dimension by "upper". */

Is the tile size specified by "sizes" wide enough in the first space * dimension, i.e., the base of the hexagon? This ensures that, * after hybrid

Given a schedule node "node" that, together with its child, * satisfies the input pattern for hybrid tiling, compute bounds * on the relative depend

Does "node" satisfy the input patttern for hybrid tiling? * That is, does "node" satisfy the properties of the outer node and * does the child of "n

Does the parent of "node" satisfy the input patttern for hybrid tiling? * That is, does "node" satisfy the properties of the inner node and * does t

Given a mark node with an identifier that points to a ppcg_ht_phase, * extract this ppcg_ht_phase pointer. */

If options->isolate_full_tiles is set, then mark the full tiles * in "node" for isolation. The full tiles are derived from "phase". * "node" may po