gpu.h

   1 #ifndef _GPU_H
   2 #define _GPU_H
   3
   4 #include <isl/ast.h>
   5 #include <isl/id_to_ast_expr.h>
   6
   7 #include "ppcg.h"
   8 #include "ppcg_options.h"
   9
  10 /* Represents an outer array accessed by a gpu_prog.
  11  * If this outer array contains structures, then the references are not
  12  * collected and the reference groups are not computed.
  13  */
  14 struct gpu_array_info {
  15         /* The array data space. */
  16         isl_space *space;
  17         /* Element type. */
  18         char *type;
  19         /* Element size. */
  20         int size;
  21         /* Name of the array. */
  22         char *name;
  23         /* Extent of the array that needs to be copied. */
  24         isl_set *extent;
  25         /* Number of indices. */
  26         unsigned n_index;
  27         /* For each index, a bound on "extent" in that direction. */
  28         isl_pw_aff **bound;
  29
  30         /* All references to this array; point to elements of a linked list. */
  31         int n_ref;
  32         struct gpu_stmt_access **refs;
  33
  34         /* The reference groups associated to this array. */
  35         int n_group;
  36         struct gpu_array_ref_group **groups;
  37
  38         /* Is this a scalar that is read-only within the entire program? */
  39         int read_only_scalar;
  40
  41         /* Are the elements of the array structures? */
  42         int has_compound_element;
  43
  44         /* Is the array local to the scop? */
  45         int local;
  46
  47         /* Should the array be linearized? */
  48         int linearize;
  49 };
  50
  51 /* For each index i, array->bound[i] specialized to the current kernel. */
  52 struct gpu_local_array_info {
  53         isl_pw_aff_list *bound;
  54 };
  55
  56 __isl_give isl_ast_expr *gpu_local_array_info_linearize_index(
  57         struct gpu_local_array_info *array, __isl_take isl_ast_expr *expr);
  58
  59 /* A sequence of "n" names of types.
  60  */
  61 struct gpu_types {
  62         int n;
  63         char **name;
  64 };
  65
  66 /* "read" and "write" contain the original access relations, possibly
  67  * involving member accesses.
  68  *
  69  * The elements of "array", as well as the ranges of "copy_in" and "copy_out"
  70  * only refer to the outer arrays of any possible member accesses.
  71  */
  72 struct gpu_prog {
  73         isl_ctx *ctx;
  74
  75         struct ppcg_scop *scop;
  76
  77         /* Set of parameter values */
  78         isl_set *context;
  79
  80         /* All read accesses in the entire program */
  81         isl_union_map *read;
  82
  83         /* All write accesses in the entire program */
  84         isl_union_map *write;
  85
  86         /* Set of outer array elements that need to be copied in. */
  87         isl_union_set *copy_in;
  88         /* Set of outer array elements that need to be copied out. */
  89         isl_union_set *copy_out;
  90
  91         /* A mapping from all innermost arrays to their outer arrays. */
  92         isl_union_map *to_outer;
  93         /* A mapping from the outer arrays to all corresponding inner arrays. */
  94         isl_union_map *to_inner;
  95
  96         /* Array of statements */
  97         int n_stmts;
  98         struct gpu_stmt *stmts;
  99
 100         int n_array;
 101         struct gpu_array_info *array;
 102 };
 103
 104 enum ppcg_kernel_access_type {
 105         ppcg_access_global,
 106         ppcg_access_shared,
 107         ppcg_access_private
 108 };
 109
 110 enum ppcg_kernel_stmt_type {
 111         ppcg_kernel_copy,
 112         ppcg_kernel_domain,
 113         ppcg_kernel_sync
 114 };
 115
 116 /* Representation of special statements, in particular copy statements
 117  * and __syncthreads statements, inside a kernel.
 118  *
 119  * type represents the kind of statement
 120  *
 121  *
 122  * for ppcg_kernel_copy statements we have
 123  *
 124  * read is set if the statement should copy data from global memory
 125  * to shared memory or registers.
 126  *
 127  * index expresses an access to the array element that needs to be copied
 128  * local_index expresses the corresponding element in the tile
 129  *
 130  * array refers to the original array being copied
 131  * local_array is a pointer to the appropriate element in the "array"
 132  *      array of the ppcg_kernel to which this copy access belongs
 133  *
 134  *
 135  * for ppcg_kernel_domain statements we have
 136  *
 137  * stmt is the corresponding input statement
 138  *
 139  * n_access is the number of accesses in stmt
 140  * access is an array of local information about the accesses
 141  */
 142 struct ppcg_kernel_stmt {
 143         enum ppcg_kernel_stmt_type type;
 144
 145         union {
 146                 struct {
 147                         int read;
 148                         isl_ast_expr *index;
 149                         isl_ast_expr *local_index;
 150                         struct gpu_array_info *array;
 151                         struct gpu_local_array_info *local_array;
 152                 } c;
 153                 struct {
 154                         struct gpu_stmt *stmt;
 155                         isl_id_to_ast_expr *ref2expr;
 156                 } d;
 157         } u;
 158 };
 159
 160 /* Representation of a local variable in a kernel.
 161  */
 162 struct ppcg_kernel_var {
 163         struct gpu_array_info *array;
 164         enum ppcg_kernel_access_type type;
 165         char *name;
 166         isl_vec *size;
 167 };
 168
 169 /* Representation of a kernel.
 170  *
 171  * id is the sequence number of the kernel.
 172  *
 173  * the first n_block elements of block_dim represent the effective size
 174  * of the block.
 175  *
 176  * grid_size reflects the effective grid size.
 177  *
 178  * context is a parametric set containing the values of the parameters
 179  * for which this kernel may be run.
 180  *
 181  * arrays is the set of accessed outer array elements.
 182  *
 183  * space is the schedule space of the AST context.  That is, it represents
 184  * the loops of the generated host code containing the kernel launch.
 185  *
 186  * n_array is the total number of arrays in the input program and also
 187  * the number of element in the array array.
 188  * array contains information about each array that is local
 189  * to the current kernel.  If an array is not used in a kernel,
 190  * then the corresponding entry does not contain any information.
 191  */
 192 struct ppcg_kernel {
 193         int id;
 194
 195         int n_block;
 196         int block_dim[3];
 197
 198         isl_multi_pw_aff *grid_size;
 199         isl_set *context;
 200
 201         isl_union_set *arrays;
 202
 203         isl_space *space;
 204
 205         int n_array;
 206         struct gpu_local_array_info *array;
 207
 208         int n_var;
 209         struct ppcg_kernel_var *var;
 210
 211         isl_ast_node *tree;
 212 };
 213
 214 int gpu_array_is_scalar(struct gpu_array_info *array);
 215 int gpu_array_is_read_only_scalar(struct gpu_array_info *array);
 216
 217 struct gpu_prog *gpu_prog_alloc(isl_ctx *ctx, struct ppcg_scop *scop);
 218 void *gpu_prog_free(struct gpu_prog *prog);
 219
 220 int generate_gpu(isl_ctx *ctx, const char *input, FILE *out,
 221         struct ppcg_options *options,
 222         __isl_give isl_printer *(*print)(__isl_take isl_printer *p,
 223                 struct gpu_prog *prog, __isl_keep isl_ast_node *tree,
 224                 struct gpu_types *types, void *user), void *user);
 225
 226 #endif