include/pet.h

   1 #ifndef PET_H
   2 #define PET_H
   3
   4 #include <isl/arg.h>
   5 #include <isl/set.h>
   6 #include <isl/map.h>
   7 #include <isl/union_map.h>
   8
   9 #if defined(__cplusplus)
  10 extern "C" {
  11 #endif
  12
  13 struct pet_options;
  14 ISL_ARG_DECL(pet_options, struct pet_options, pet_options_args)
  15
  16 /* If autodetect is set, any valid scop is extracted.
  17  * Otherwise, the scop needs to be delimited by pragmas.
  18  */
  19 int pet_options_set_autodetect(isl_ctx *ctx, int val);
  20 int pet_options_get_autodetect(isl_ctx *ctx);
  21
  22 enum pet_expr_type {
  23         pet_expr_access,
  24         pet_expr_call,
  25         pet_expr_double,
  26         pet_expr_unary,
  27         pet_expr_binary,
  28         pet_expr_ternary
  29 };
  30
  31 enum pet_op_type {
  32         /* only compound assignments operators before assignment */
  33         pet_op_add_assign,
  34         pet_op_sub_assign,
  35         pet_op_mul_assign,
  36         pet_op_div_assign,
  37         pet_op_assign,
  38         pet_op_add,
  39         pet_op_sub,
  40         pet_op_mul,
  41         pet_op_div,
  42         pet_op_eq,
  43         pet_op_le,
  44         pet_op_lt,
  45         pet_op_gt,
  46         pet_op_minus,
  47         pet_op_address_of,
  48         pet_op_last
  49 };
  50
  51 /* Index into the pet_expr->args array when pet_expr->type == pet_expr_unary
  52  */
  53 enum pet_un_arg_type {
  54         pet_un_arg
  55 };
  56
  57 /* Indices into the pet_expr->args array when
  58  * pet_expr->type == pet_expr_binary
  59  */
  60 enum pet_bin_arg_type {
  61         pet_bin_lhs,
  62         pet_bin_rhs
  63 };
  64
  65 /* Indices into the pet_expr->args array when
  66  * pet_expr->type == pet_expr_ternary
  67  */
  68 enum pet_ter_arg_type {
  69         pet_ter_cond,
  70         pet_ter_true,
  71         pet_ter_false
  72 };
  73
  74 /* d is valid when type == pet_expr_double
  75  * acc is valid when type == pet_expr_access
  76  * call is valid when type == pet_expr_call
  77  * op is valid otherwise
  78  *
  79  * acc.access usually maps an iteration space to a data space.
  80  * If the access has arguments, however, then the domain of the
  81  * mapping is a wrapped mapping from the iteration space
  82  * to a space of dimensionality equal to the number of arguments.
  83  * Each dimension in this space corresponds to the value of the
  84  * corresponding argument.
  85  *
  86  * If the data space is unnamed (and 1D), then it represents
  87  * the set of integers.  That is, the access represents a value that
  88  * is equal to the index.
  89  */
  90 struct pet_expr {
  91         enum pet_expr_type type;
  92
  93         unsigned n_arg;
  94         struct pet_expr **args;
  95
  96         union {
  97                 struct {
  98                         isl_map *access;
  99                         int read;
 100                         int write;
 101                 } acc;
 102                 enum pet_op_type op;
 103                 char *name;
 104                 double d;
 105         };
 106 };
 107
 108 /* If the statement has arguments, i.e., n_arg != 0, then
 109  * "domain" is a wrapped map, mapping the iteration domain
 110  * to the values of the arguments for which this statement
 111  * is executed.
 112  * Otherwise, it is simply the iteration domain.
 113  */
 114 struct pet_stmt {
 115         int line;
 116         isl_set *domain;
 117         isl_map *schedule;
 118         struct pet_expr *body;
 119
 120         unsigned n_arg;
 121         struct pet_expr **args;
 122 };
 123
 124 /* context holds constraints on the parameter that ensure that
 125  * this array has a valid (i.e., non-negative) size
 126  *
 127  * extent holds constraints on the indices
 128  *
 129  * value_bounds holds constraints on the elements of the array
 130  * and may be NULL if no such constraints were specified by the user
 131  *
 132  * element_size is the size in bytes of each array element
 133  *
 134  * live_out is set if the array appears in a live-out pragma
 135  *
 136  * if uniquely_defined is set then the array is written by a single access
 137  * such that any element that is ever read
 138  * is known to be assigned exactly once before the read
 139  */
 140 struct pet_array {
 141         isl_set *context;
 142         isl_set *extent;
 143         isl_set *value_bounds;
 144         char *element_type;
 145         int element_size;
 146         int live_out;
 147         int uniquely_defined;
 148 };
 149
 150 /* The context describes the set of parameter values for which
 151  * the scop can be executed.
 152  * context_value describes assignments to the parameters (if any)
 153  * outside of the scop.
 154  */
 155 struct pet_scop {
 156         isl_set *context;
 157         isl_set *context_value;
 158
 159         int n_array;
 160         struct pet_array **arrays;
 161
 162         int n_stmt;
 163         struct pet_stmt **stmts;
 164 };
 165
 166 /* Return a textual representation of the operator. */
 167 const char *pet_op_str(enum pet_op_type op);
 168
 169 /* Extract a pet_scop from a C source file.
 170  * If function is not NULL, then the pet_scop is extracted from
 171  * a function with that name.
 172  */
 173 struct pet_scop *pet_scop_extract_from_C_source(isl_ctx *ctx,
 174         const char *filename, const char *function);
 175
 176 /* Update all isl_sets and isl_maps such that they all have the same
 177  * parameters in the same order.
 178  */
 179 struct pet_scop *pet_scop_align_params(struct pet_scop *scop);
 180
 181 void pet_scop_dump(struct pet_scop *scop);
 182 void *pet_scop_free(struct pet_scop *scop);
 183
 184 __isl_give isl_union_set *pet_scop_collect_domains(struct pet_scop *scop);
 185 /* Collect all read access relations. */
 186 __isl_give isl_union_map *pet_scop_collect_reads(struct pet_scop *scop);
 187 /* Collect all write access relations. */
 188 __isl_give isl_union_map *pet_scop_collect_writes(struct pet_scop *scop);
 189 __isl_give isl_union_map *pet_scop_collect_schedule(struct pet_scop *scop);
 190
 191 #if defined(__cplusplus)
 192 }
 193 #endif
 194
 195 #endif