gpu.h

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