codegen.c

   1 /*
   2  * Copyright 2012,2014 Ecole Normale Superieure
   3  *
   4  * Use of this software is governed by the MIT license
   5  *
   6  * Written by Sven Verdoolaege,
   7  * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
   8  */
   9
  10 /* This program prints an AST that scans the domain elements of
  11  * the domain of a given schedule in the order specified by
  12  * the schedule tree or by their image(s) in the schedule map.
  13  *
  14  * The input consists of either a schedule tree or
  15  * a sequence of three sets/relations.
  16  * - a schedule map
  17  * - a context
  18  * - a relation describing AST generation options
  19  */
  20
  21 #include <assert.h>
  22 #include <stdlib.h>
  23 #include <isl/ast.h>
  24 #include <isl/ast_build.h>
  25 #include <isl/options.h>
  26 #include <isl/space.h>
  27 #include <isl/set.h>
  28 #include <isl/union_set.h>
  29 #include <isl/union_map.h>
  30 #include <isl/stream.h>
  31 #include <isl/schedule_node.h>
  32
  33 struct options {
  34         struct isl_options      *isl;
  35         unsigned                 atomic;
  36         unsigned                 separate;
  37 };
  38
  39 ISL_ARGS_START(struct options, options_args)
  40 ISL_ARG_CHILD(struct options, isl, "isl", &isl_options_args, "isl options")
  41 ISL_ARG_BOOL(struct options, atomic, 0, "atomic", 0,
  42         "globally set the atomic option")
  43 ISL_ARG_BOOL(struct options, separate, 0, "separate", 0,
  44         "globally set the separate option")
  45 ISL_ARGS_END
  46
  47 ISL_ARG_DEF(cg_options, struct options, options_args)
  48 ISL_ARG_CTX_DEF(cg_options, struct options, options_args)
  49
  50 /* Return a universal, 1-dimensional set with the given name.
  51  */
  52 static __isl_give isl_union_set *universe(isl_ctx *ctx, const char *name)
  53 {
  54         isl_space *space;
  55
  56         space = isl_space_set_alloc(ctx, 0, 1);
  57         space = isl_space_set_tuple_name(space, isl_dim_set, name);
  58         return isl_union_set_from_set(isl_set_universe(space));
  59 }
  60
  61 /* Set the "name" option for the entire schedule domain.
  62  */
  63 static __isl_give isl_union_map *set_universe(__isl_take isl_union_map *opt,
  64         __isl_keep isl_union_map *schedule, const char *name)
  65 {
  66         isl_ctx *ctx;
  67         isl_union_set *domain, *target;
  68         isl_union_map *option;
  69
  70         ctx = isl_union_map_get_ctx(opt);
  71
  72         domain = isl_union_map_range(isl_union_map_copy(schedule));
  73         domain = isl_union_set_universe(domain);
  74         target = universe(ctx, name);
  75         option = isl_union_map_from_domain_and_range(domain, target);
  76         opt = isl_union_map_union(opt, option);
  77
  78         return opt;
  79 }
  80
  81 /* Update the build options based on the user-specified options.
  82  *
  83  * If the --separate or --atomic options were specified, then
  84  * we clear any separate or atomic options that may already exist in "opt".
  85  */
  86 static __isl_give isl_ast_build *set_options(__isl_take isl_ast_build *build,
  87         __isl_take isl_union_map *opt, struct options *options,
  88         __isl_keep isl_union_map *schedule)
  89 {
  90         if (options->separate || options->atomic) {
  91                 isl_ctx *ctx;
  92                 isl_union_set *target;
  93
  94                 ctx = isl_union_map_get_ctx(schedule);
  95
  96                 target = universe(ctx, "separate");
  97                 opt = isl_union_map_subtract_range(opt, target);
  98                 target = universe(ctx, "atomic");
  99                 opt = isl_union_map_subtract_range(opt, target);
 100         }
 101
 102         if (options->separate)
 103                 opt = set_universe(opt, schedule, "separate");
 104         if (options->atomic)
 105                 opt = set_universe(opt, schedule, "atomic");
 106
 107         build = isl_ast_build_set_options(build, opt);
 108
 109         return build;
 110 }
 111
 112 /* Construct an AST in case the schedule is specified by a union map.
 113  *
 114  * We read the context and the options from "s" and construct the AST.
 115  */
 116 static __isl_give isl_ast_node *construct_ast_from_union_map(
 117         __isl_take isl_union_map *schedule, __isl_keep isl_stream *s)
 118 {
 119         isl_set *context;
 120         isl_union_map *options_map;
 121         isl_ast_build *build;
 122         isl_ast_node *tree;
 123         struct options *options;
 124
 125         options = isl_ctx_peek_cg_options(isl_stream_get_ctx(s));
 126
 127         context = isl_stream_read_set(s);
 128         options_map = isl_stream_read_union_map(s);
 129
 130         build = isl_ast_build_from_context(context);
 131         build = set_options(build, options_map, options, schedule);
 132         tree = isl_ast_build_node_from_schedule_map(build, schedule);
 133         isl_ast_build_free(build);
 134
 135         return tree;
 136 }
 137
 138 /* If "node" is a band node, then replace the AST build options
 139  * by "options".
 140  */
 141 static __isl_give isl_schedule_node *node_set_options(
 142         __isl_take isl_schedule_node *node, void *user)
 143 {
 144         enum isl_ast_loop_type *type = user;
 145         int i;
 146         isl_size n;
 147
 148         if (isl_schedule_node_get_type(node) != isl_schedule_node_band)
 149                 return node;
 150
 151         n = isl_schedule_node_band_n_member(node);
 152         if (n < 0)
 153                 return isl_schedule_node_free(node);
 154         for (i = 0; i < n; ++i)
 155                 node = isl_schedule_node_band_member_set_ast_loop_type(node,
 156                                                                 i, *type);
 157         return node;
 158 }
 159
 160 /* Replace the AST build options on all band nodes if requested
 161  * by the user.
 162  */
 163 static __isl_give isl_schedule *schedule_set_options(
 164         __isl_take isl_schedule *schedule, struct options *options)
 165 {
 166         enum isl_ast_loop_type type;
 167
 168         if (!options->separate && !options->atomic)
 169                 return schedule;
 170
 171         type = options->separate ? isl_ast_loop_separate : isl_ast_loop_atomic;
 172         schedule = isl_schedule_map_schedule_node_bottom_up(schedule,
 173                                                 &node_set_options, &type);
 174
 175         return schedule;
 176 }
 177
 178 /* Construct an AST in case the schedule is specified by a schedule tree.
 179  */
 180 static __isl_give isl_ast_node *construct_ast_from_schedule(
 181         __isl_take isl_schedule *schedule)
 182 {
 183         isl_ast_build *build;
 184         isl_ast_node *tree;
 185         struct options *options;
 186
 187         options = isl_ctx_peek_cg_options(isl_schedule_get_ctx(schedule));
 188
 189         build = isl_ast_build_alloc(isl_schedule_get_ctx(schedule));
 190         schedule = schedule_set_options(schedule, options);
 191         tree = isl_ast_build_node_from_schedule(build, schedule);
 192         isl_ast_build_free(build);
 193
 194         return tree;
 195 }
 196
 197 /* Read an object from stdin.
 198  * If it is a (union) map, then assume an input specified by
 199  * schedule map, context and options and construct an AST from
 200  * those elements
 201  * If it is a schedule object, then construct the AST from the schedule.
 202  */
 203 int main(int argc, char **argv)
 204 {
 205         isl_ctx *ctx;
 206         isl_stream *s;
 207         isl_ast_node *tree = NULL;
 208         struct options *options;
 209         isl_printer *p;
 210         struct isl_obj obj;
 211         int r = EXIT_SUCCESS;
 212
 213         options = cg_options_new_with_defaults();
 214         assert(options);
 215         ctx = isl_ctx_alloc_with_options(&options_args, options);
 216         isl_options_set_ast_build_detect_min_max(ctx, 1);
 217         isl_options_set_ast_print_outermost_block(ctx, 0);
 218         argc = cg_options_parse(options, argc, argv, ISL_ARG_ALL);
 219
 220         s = isl_stream_new_file(ctx, stdin);
 221         obj = isl_stream_read_obj(s);
 222         if (obj.v == NULL) {
 223                 r = EXIT_FAILURE;
 224         } else if (obj.type == isl_obj_map) {
 225                 isl_union_map *umap;
 226
 227                 umap = isl_union_map_from_map(obj.v);
 228                 tree = construct_ast_from_union_map(umap, s);
 229         } else if (obj.type == isl_obj_union_map) {
 230                 tree = construct_ast_from_union_map(obj.v, s);
 231         } else if (obj.type == isl_obj_schedule) {
 232                 tree = construct_ast_from_schedule(obj.v);
 233         } else {
 234                 obj.type->free(obj.v);
 235                 isl_die(ctx, isl_error_invalid, "unknown input",
 236                         r = EXIT_FAILURE);
 237         }
 238         isl_stream_free(s);
 239
 240         p = isl_printer_to_file(ctx, stdout);
 241         p = isl_printer_set_output_format(p, ISL_FORMAT_C);
 242         p = isl_printer_print_ast_node(p, tree);
 243         isl_printer_free(p);
 244
 245         isl_ast_node_free(tree);
 246
 247         isl_ctx_free(ctx);
 248         return r;
 249 }