Given a pointer "node" to (a copy of) the original child node * in the input pattern, adjust its partial schedule such that * it starts at zero with

Return a new reference to "tiling". */

Return the isl_ctx to which "tiling" belongs. */

Set the project_ts field of "tiling". * * This field projects the space of the input schedule to the ts-space. * It is equal to [P[t] -> C[s_0, ...

Create the array of gpu_local_array_info structures "array" * inside "kernel". The number of elements in this array is * the same as the number of

Free the memory allocated by a struct ppcg_macros. */

Construct an isl_multi_val living in "space" with all values equal to "val". */

Print a declaration for array "array" to "p", using "build" * to simplify any size expressions. * * The size is computed from the extent of the arr

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

Extract a ppcg_scop from a pet_scop. * * The constructed ppcg_scop refers to elements from the pet_scop * so the pet_scop should not be freed befor

Set the macro definitions for isl_ast_op_min and isl_ast_op_max * to "min" and "max" and store them in "p". * * In particular, create a ppcg_macros

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

Print a statement for copying an array to or from the device, * or for initializing or clearing the device. * The statement identifier of a copying

Print a statement for copying an array to or from the device, * or for initializing or clearing the device. * The statement identifier of a copying

Print a for loop node as an openmp parallel loop. * * To print an openmp parallel loop we print a normal for loop, but add * "#pragma openmp parall

Print the grid definition. */

Print the effective grid size as a list of the sizes in each * dimension, from innermost to outermost. */

Print the header of the given kernel to both gen->cuda.kernel_h * and gen->cuda.kernel_c. */

Print the currently active macro definition for ppcg_max. */

Print the currently active macro definition for ppcg_min. */

Print the declaration of a non-linearized array argument. */

Print the body of a statement from the input program, * for use in OpenCL code. * * Before calling ppcg_kernel_print_domain to print the actual sta

Should we print the original code? * That is, does "scop" involve any data dependent conditions or * nested expressions that cannot be handled by pe

Code generate the scop 'scop' using "schedule" * and print the corresponding C code to 'p'. */

Print a sync statement. */

Has the macro definition corresponding to "note_name" been printed * to "p" before? * That is, does "p" have an associated "note_name" note? */

Given a union of "tagged" access relations of the form * * [S_i[...] -> R_j[]] -> A_k[...] * * project out the "tags" (R_j[]). * That is, return

Extract user specified "block" sizes from the "sizes" command line option, * after filling in some potentially useful defaults. */

Extract user specified grid and block sizes from the gen->sizes * command line option after filling in some potentially useful defaults. * Store the

Extract user specified "grid" sizes from the "sizes" command line option, * after filling in some potentially useful defaults. */

Free the device array corresponding to "array" */

Remove the validity schedule constraints from "sc" between * statement instances that get contracted to the same group instance * by the contraction

Remove independence from the order constraints "order" on array "array". * Since the pairs of iterations in the filter relation of an independence *

Remove independence from the tagged flow dependences. * Since the user has guaranteed that source and sink of an independence * can be executed in a

Given an access relation "access" from "group", remove those reads * if ("read" is 1) or writes (if "read" is 0) that are only needed to * communica

Given an array access "access", remove the strides based * on the information in tile->bound[i]->stride and tile->bound[i]->shift. * * In particula

Report that the given grouping is used during scheduling * (if the verbose options is set). */

Report that the array reference group with the given access relation * is not mapped to shared memory in the given kernel because * it does not exhi

Save the schedule "schedule" to a file called "filename". * The schedule is printed in block style. */

Scale a band node that may have been split by split_band. * "sizes" are the scaling factors for the original node. * "node" either points to the ori

Construct a schedule with "domain" as domain, that executes * the elements of "list" in order (as a sequence). */

Determine the number of schedule dimensions that affect the offset of the * shared tile and store the minimum of the private and shared tile depth *

Intersect "set" with the set described by "str", taking the NULL * string to represent the universal set. */

Copy the AST loop types of the non-isolated part to those * of the isolated part. */

Set the macro definitions for ppcg_min and ppcg_max to * OpenCL specific versions. */

Replace "pa" by the zero function defined over the universe domain * in the space of "pa". */

Map the domain of "access" to the outer data->shared_depth * schedule dimensions. When data->shared_depth is equal to * data->thread_depth, this re

Pullback "phase" over phase->tiling->shift_phase, which shifts * phase 0 to phase 1. The pullback therefore takes a phase 1 * description and turns

Is the size of the tile specified by "tile" smaller than the sum of * the sizes of the tiles specified by "tile1" and "tile2"? */

Given a description of an array tile "tile" and the "space" * * { D -> A } * * where D represents the first tile->depth schedule dimensions * and

Tile the band node "node" with tile sizes "sizes" and * mark all members of the resulting tile node as "atomic". */

Tile "band" with tile size specified by "sizes". * * Since the tile loops will be mapped to block ids, we forcibly * turn off tile loop scaling. W

Given an index expression "index" of the form * * L -> F(A), * * with F(A) either A or some subfield of A and L the AST loop iterators, * and a t

Determine the number of schedule dimensions that affect the offset of the * shared or private tile "tile" and store the result in tile->depth, with

See if hybrid tiling can be performed on "node" and its parent. * If so, apply hybrid tiling and return the updated schedule tree. * If not, return

Update the information in "data" based on the band ancestor "node". * * In particular, we restrict the dependences in data->local_flow * to those d

Update the information in "data" based on the filter ancestor "node". * We only need to modify anything if the filter is the child * of a set or seq

Check if the access relations of group1 and group2 overlap within * copy_sched. */

This function is called after the AST generator has finished traversing * the schedule subtree of a mark node. "node" points to the corresponding *

This method is executed after the construction of a for node. * * It performs the following actions: * * - Reset the 'in_parallel_for' flag, as s

This method is executed before the construction of a for node. It creates * an isl_id that is used to annotate the subsequently generated ast for nod

This function is called for each instance of a user statement * in the kernel. This may be one of the original user statements * or a statement int

Transform the accesses in the statement associated to the domain * called by "node" to refer to the AST loop iterators, construct * corresponding AS

This function is called for each node in a GPU AST. * In case of a user node, print the macro definitions required * for printing the AST expression

This function is called for each node in a CPU AST. * In case of a user node, print the macro definitions required * for printing the AST expression

This function is called before the AST generator starts traversing * the schedule subtree of a node with mark "mark". * * If the mark is called "ke

This function is a callback for pet_tree_foreach_expr. * If "expr" contains any call (sub)expressions, then set *has_call * and abort the search. *

Given a set of validity and proximity schedule constraints "map" * between statements in consecutive leaves in a valid schedule, * should the two le

Compute a schedule or determine the properties of the original schedule * depending on the value of the "reschedule" option. */

If "node" is a sequence, then check if it has any consecutive * leaves that should be merged together and store the results * in "grouping". * * I

This function is called on each of the two phase marks * in a hybrid tiling tree. * Drop the phase mark at "node". */

Extract a gpu_stmt_access from "expr", append it to the list * that ends in *data->next_access and update the end of the list. * If the access expre

This function is called for each set in a union_set. * If the name of the set matches data->type, we store the * set in data->res. */

Free an ast_node_info structure. */

Wrapper around generate for use as a ppcg_transform callback. */

Does "stmt" contain any call expressions? */

Is "stmt" not a kill statement? */