ppcg.c

   1 /*
   2  * Copyright 2011      INRIA Saclay
   3  *
   4  * Use of this software is governed by the GNU LGPLv2.1 license
   5  *
   6  * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
   7  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
   8  * 91893 Orsay, France
   9  */
  10
  11 #include <assert.h>
  12 #include <stdio.h>
  13 #include <isl/ctx.h>
  14 #include <isl/flow.h>
  15 #include <isl/options.h>
  16 #include <isl/schedule.h>
  17 #include <pet.h>
  18 #include "ppcg.h"
  19 #include "ppcg_options.h"
  20 #include "cuda.h"
  21 #include "cpu.h"
  22
  23 struct options {
  24         struct isl_options *isl;
  25         struct pet_options *pet;
  26         struct ppcg_options *ppcg;
  27         char *input;
  28 };
  29
  30 const char *ppcg_version(void);
  31 static void print_version(void)
  32 {
  33         printf("%s", ppcg_version());
  34 }
  35
  36 ISL_ARGS_START(struct options, options_args)
  37 ISL_ARG_CHILD(struct options, isl, "isl", &isl_options_args, "isl options")
  38 ISL_ARG_CHILD(struct options, pet, "pet", &pet_options_args, "pet options")
  39 ISL_ARG_CHILD(struct options, ppcg, NULL, &ppcg_options_args, "ppcg options")
  40 ISL_ARG_ARG(struct options, input, "input", NULL)
  41 ISL_ARG_VERSION(print_version)
  42 ISL_ARGS_END
  43
  44 ISL_ARG_DEF(options, struct options, options_args)
  45
  46 /* Is "stmt" a kill statement?
  47  */
  48 static int is_kill(struct pet_stmt *stmt)
  49 {
  50         if (stmt->body->type != pet_expr_unary)
  51                 return 0;
  52         return stmt->body->op == pet_op_kill;
  53 }
  54
  55 /* Is "stmt" not a kill statement?
  56  */
  57 static int is_not_kill(struct pet_stmt *stmt)
  58 {
  59         return !is_kill(stmt);
  60 }
  61
  62 /* Collect the iteration domains of the statements in "scop" that
  63  * satisfy "pred".
  64  */
  65 static __isl_give isl_union_set *collect_domains(struct pet_scop *scop,
  66         int (*pred)(struct pet_stmt *stmt))
  67 {
  68         int i;
  69         isl_set *domain_i;
  70         isl_union_set *domain;
  71
  72         if (!scop)
  73                 return NULL;
  74
  75         domain = isl_union_set_empty(isl_set_get_space(scop->context));
  76
  77         for (i = 0; i < scop->n_stmt; ++i) {
  78                 struct pet_stmt *stmt = scop->stmts[i];
  79
  80                 if (!pred(stmt))
  81                         continue;
  82                 domain_i = isl_set_copy(scop->stmts[i]->domain);
  83                 domain = isl_union_set_add_set(domain, domain_i);
  84         }
  85
  86         return domain;
  87 }
  88
  89 /* Collect the iteration domains of the statements in "scop",
  90  * skipping kill statements.
  91  */
  92 static __isl_give isl_union_set *collect_non_kill_domains(struct pet_scop *scop)
  93 {
  94         return collect_domains(scop, &is_not_kill);
  95 }
  96
  97 /* Does "expr" contain any call expressions?
  98  */
  99 static int expr_has_call(struct pet_expr *expr)
 100 {
 101         int i;
 102
 103         if (expr->type == pet_expr_call)
 104                 return 1;
 105
 106         for (i = 0; i < expr->n_arg; ++i)
 107                 if (expr_has_call(expr->args[i]))
 108                         return 1;
 109
 110         return 0;
 111 }
 112
 113 /* Does "stmt" contain any call expressions?
 114  */
 115 static int has_call(struct pet_stmt *stmt)
 116 {
 117         return expr_has_call(stmt->body);
 118 }
 119
 120 /* Collect the iteration domains of the statements in "scop"
 121  * that contain a call expression.
 122  */
 123 static __isl_give isl_union_set *collect_call_domains(struct pet_scop *scop)
 124 {
 125         return collect_domains(scop, &has_call);
 126 }
 127
 128 /* Collect all kill accesses in "scop".
 129  */
 130 static __isl_give isl_union_map *collect_kills(struct pet_scop *scop)
 131 {
 132         int i;
 133         isl_union_map *kills;
 134
 135         if (!scop)
 136                 return NULL;
 137
 138         kills = isl_union_map_empty(isl_set_get_space(scop->context));
 139
 140         for (i = 0; i < scop->n_stmt; ++i) {
 141                 struct pet_stmt *stmt = scop->stmts[i];
 142                 isl_map *kill_i;
 143
 144                 if (!is_kill(stmt))
 145                         continue;
 146                 kill_i = isl_map_copy(stmt->body->args[0]->acc.access);
 147                 kills = isl_union_map_add_map(kills, kill_i);
 148         }
 149
 150         return kills;
 151 }
 152
 153 /* Compute (flow) dependences and store the resulting flow dependences
 154  * in scop->dep_flow and the reads with no corresponding writes in
 155  * scop->live_in.
 156  */
 157 static void compute_dependences(struct ppcg_scop *scop)
 158 {
 159         isl_union_map *empty;
 160
 161         if (!scop)
 162                 return;
 163
 164         empty = isl_union_map_empty(isl_union_set_get_space(scop->domain));
 165         isl_union_map_compute_flow(isl_union_map_copy(scop->reads),
 166                                 isl_union_map_copy(scop->writes), empty,
 167                                 isl_union_map_copy(scop->schedule),
 168                                 &scop->dep_flow, NULL, &scop->live_in, NULL);
 169 }
 170
 171 /* Extract a ppcg_scop from a pet_scop.
 172  *
 173  * The constructed ppcg_scop refers to elements from the pet_scop
 174  * so the pet_scop should not be freed before the ppcg_scop.
 175  */
 176 static struct ppcg_scop *ppcg_scop_from_pet_scop(struct pet_scop *scop)
 177 {
 178         isl_ctx *ctx;
 179         struct ppcg_scop *ps;
 180
 181         if (!scop)
 182                 return NULL;
 183
 184         ctx = isl_set_get_ctx(scop->context);
 185
 186         ps = isl_calloc_type(ctx, struct ppcg_scop);
 187         if (!ps)
 188                 return NULL;
 189
 190         ps->context = isl_set_copy(scop->context);
 191         ps->domain = collect_non_kill_domains(scop);
 192         ps->call = collect_call_domains(scop);
 193         ps->reads = pet_scop_collect_reads(scop);
 194         ps->writes = pet_scop_collect_writes(scop);
 195         ps->kills = collect_kills(scop);
 196         ps->schedule = pet_scop_collect_schedule(scop);
 197         ps->n_array = scop->n_array;
 198         ps->arrays = scop->arrays;
 199         ps->n_stmt = scop->n_stmt;
 200         ps->stmts = scop->stmts;
 201
 202         compute_dependences(ps);
 203
 204         return ps;
 205 }
 206
 207 static void ppcg_scop_free(struct ppcg_scop *ps)
 208 {
 209         if (!ps)
 210                 return;
 211
 212         isl_set_free(ps->context);
 213         isl_union_set_free(ps->domain);
 214         isl_union_set_free(ps->call);
 215         isl_union_map_free(ps->reads);
 216         isl_union_map_free(ps->live_in);
 217         isl_union_map_free(ps->writes);
 218         isl_union_map_free(ps->kills);
 219         isl_union_map_free(ps->dep_flow);
 220         isl_union_map_free(ps->schedule);
 221
 222         free(ps);
 223 }
 224
 225 int main(int argc, char **argv)
 226 {
 227         int r;
 228         isl_ctx *ctx;
 229         struct options *options;
 230         struct pet_scop *scop;
 231         struct ppcg_scop *ps;
 232
 233         options = options_new_with_defaults();
 234         assert(options);
 235
 236         ctx = isl_ctx_alloc_with_options(&options_args, options);
 237         isl_options_set_schedule_outer_zero_distance(ctx, 1);
 238         argc = options_parse(options, argc, argv, ISL_ARG_ALL);
 239
 240         scop = pet_scop_extract_from_C_source(ctx, options->input, NULL);
 241         scop = pet_scop_align_params(scop);
 242         ps = ppcg_scop_from_pet_scop(scop);
 243
 244         if (options->ppcg->target == PPCG_TARGET_CUDA)
 245                 r = generate_cuda(ctx, ps, options->ppcg, options->input);
 246         else
 247                 r = generate_cpu(ctx, ps, options->ppcg, options->input);
 248
 249         ppcg_scop_free(ps);
 250         pet_scop_free(scop);
 251
 252         isl_ctx_free(ctx);
 253
 254         return r;
 255 }