246 lines
6.7 KiB
C
246 lines
6.7 KiB
C
/*
|
||
* Copyright 2012,2014 Ecole Normale Superieure
|
||
*
|
||
* Use of this software is governed by the MIT license
|
||
*
|
||
* Written by Sven Verdoolaege,
|
||
* Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
|
||
*/
|
||
|
||
/* This program prints an AST that scans the domain elements of
|
||
* the domain of a given schedule in the order specified by
|
||
* the schedule tree or by their image(s) in the schedule map.
|
||
*
|
||
* The input consists of either a schedule tree or
|
||
* a sequence of three sets/relations.
|
||
* - a schedule map
|
||
* - a context
|
||
* - a relation describing AST generation options
|
||
*/
|
||
|
||
#include <assert.h>
|
||
#include <stdlib.h>
|
||
#include <isl/ast.h>
|
||
#include <isl/ast_build.h>
|
||
#include <isl/options.h>
|
||
#include <isl/space.h>
|
||
#include <isl/set.h>
|
||
#include <isl/union_set.h>
|
||
#include <isl/union_map.h>
|
||
#include <isl/stream.h>
|
||
#include <isl/schedule_node.h>
|
||
|
||
struct options {
|
||
struct isl_options *isl;
|
||
unsigned atomic;
|
||
unsigned separate;
|
||
};
|
||
|
||
ISL_ARGS_START(struct options, options_args)
|
||
ISL_ARG_CHILD(struct options, isl, "isl", &isl_options_args, "isl options")
|
||
ISL_ARG_BOOL(struct options, atomic, 0, "atomic", 0,
|
||
"globally set the atomic option")
|
||
ISL_ARG_BOOL(struct options, separate, 0, "separate", 0,
|
||
"globally set the separate option")
|
||
ISL_ARGS_END
|
||
|
||
ISL_ARG_DEF(cg_options, struct options, options_args)
|
||
ISL_ARG_CTX_DEF(cg_options, struct options, options_args)
|
||
|
||
/* Return a universal, 1-dimensional set with the given name.
|
||
*/
|
||
static __isl_give isl_union_set *universe(isl_ctx *ctx, const char *name)
|
||
{
|
||
isl_space *space;
|
||
|
||
space = isl_space_set_alloc(ctx, 0, 1);
|
||
space = isl_space_set_tuple_name(space, isl_dim_set, name);
|
||
return isl_union_set_from_set(isl_set_universe(space));
|
||
}
|
||
|
||
/* Set the "name" option for the entire schedule domain.
|
||
*/
|
||
static __isl_give isl_union_map *set_universe(__isl_take isl_union_map *opt,
|
||
__isl_keep isl_union_map *schedule, const char *name)
|
||
{
|
||
isl_ctx *ctx;
|
||
isl_union_set *domain, *target;
|
||
isl_union_map *option;
|
||
|
||
ctx = isl_union_map_get_ctx(opt);
|
||
|
||
domain = isl_union_map_range(isl_union_map_copy(schedule));
|
||
domain = isl_union_set_universe(domain);
|
||
target = universe(ctx, name);
|
||
option = isl_union_map_from_domain_and_range(domain, target);
|
||
opt = isl_union_map_union(opt, option);
|
||
|
||
return opt;
|
||
}
|
||
|
||
/* Update the build options based on the user-specified options.
|
||
*
|
||
* If the --separate or --atomic options were specified, then
|
||
* we clear any separate or atomic options that may already exist in "opt".
|
||
*/
|
||
static __isl_give isl_ast_build *set_options(__isl_take isl_ast_build *build,
|
||
__isl_take isl_union_map *opt, struct options *options,
|
||
__isl_keep isl_union_map *schedule)
|
||
{
|
||
if (options->separate || options->atomic) {
|
||
isl_ctx *ctx;
|
||
isl_union_set *target;
|
||
|
||
ctx = isl_union_map_get_ctx(schedule);
|
||
|
||
target = universe(ctx, "separate");
|
||
opt = isl_union_map_subtract_range(opt, target);
|
||
target = universe(ctx, "atomic");
|
||
opt = isl_union_map_subtract_range(opt, target);
|
||
}
|
||
|
||
if (options->separate)
|
||
opt = set_universe(opt, schedule, "separate");
|
||
if (options->atomic)
|
||
opt = set_universe(opt, schedule, "atomic");
|
||
|
||
build = isl_ast_build_set_options(build, opt);
|
||
|
||
return build;
|
||
}
|
||
|
||
/* Construct an AST in case the schedule is specified by a union map.
|
||
*
|
||
* We read the context and the options from "s" and construct the AST.
|
||
*/
|
||
static __isl_give isl_ast_node *construct_ast_from_union_map(
|
||
__isl_take isl_union_map *schedule, __isl_keep isl_stream *s)
|
||
{
|
||
isl_set *context;
|
||
isl_union_map *options_map;
|
||
isl_ast_build *build;
|
||
isl_ast_node *tree;
|
||
struct options *options;
|
||
|
||
options = isl_ctx_peek_cg_options(isl_stream_get_ctx(s));
|
||
|
||
context = isl_stream_read_set(s);
|
||
options_map = isl_stream_read_union_map(s);
|
||
|
||
build = isl_ast_build_from_context(context);
|
||
build = set_options(build, options_map, options, schedule);
|
||
tree = isl_ast_build_node_from_schedule_map(build, schedule);
|
||
isl_ast_build_free(build);
|
||
|
||
return tree;
|
||
}
|
||
|
||
/* If "node" is a band node, then replace the AST build options
|
||
* by "options".
|
||
*/
|
||
static __isl_give isl_schedule_node *node_set_options(
|
||
__isl_take isl_schedule_node *node, void *user)
|
||
{
|
||
enum isl_ast_loop_type *type = user;
|
||
int i, n;
|
||
|
||
if (isl_schedule_node_get_type(node) != isl_schedule_node_band)
|
||
return node;
|
||
|
||
n = isl_schedule_node_band_n_member(node);
|
||
for (i = 0; i < n; ++i)
|
||
node = isl_schedule_node_band_member_set_ast_loop_type(node,
|
||
i, *type);
|
||
return node;
|
||
}
|
||
|
||
/* Replace the AST build options on all band nodes if requested
|
||
* by the user.
|
||
*/
|
||
static __isl_give isl_schedule *schedule_set_options(
|
||
__isl_take isl_schedule *schedule, struct options *options)
|
||
{
|
||
enum isl_ast_loop_type type;
|
||
|
||
if (!options->separate && !options->atomic)
|
||
return schedule;
|
||
|
||
type = options->separate ? isl_ast_loop_separate : isl_ast_loop_atomic;
|
||
schedule = isl_schedule_map_schedule_node_bottom_up(schedule,
|
||
&node_set_options, &type);
|
||
|
||
return schedule;
|
||
}
|
||
|
||
/* Construct an AST in case the schedule is specified by a schedule tree.
|
||
*/
|
||
static __isl_give isl_ast_node *construct_ast_from_schedule(
|
||
__isl_take isl_schedule *schedule)
|
||
{
|
||
isl_ast_build *build;
|
||
isl_ast_node *tree;
|
||
struct options *options;
|
||
|
||
options = isl_ctx_peek_cg_options(isl_schedule_get_ctx(schedule));
|
||
|
||
build = isl_ast_build_alloc(isl_schedule_get_ctx(schedule));
|
||
schedule = schedule_set_options(schedule, options);
|
||
tree = isl_ast_build_node_from_schedule(build, schedule);
|
||
isl_ast_build_free(build);
|
||
|
||
return tree;
|
||
}
|
||
|
||
/* Read an object from stdin.
|
||
* If it is a (union) map, then assume an input specified by
|
||
* schedule map, context and options and construct an AST from
|
||
* those elements
|
||
* If it is a schedule object, then construct the AST from the schedule.
|
||
*/
|
||
int main(int argc, char **argv)
|
||
{
|
||
isl_ctx *ctx;
|
||
isl_stream *s;
|
||
isl_ast_node *tree = NULL;
|
||
struct options *options;
|
||
isl_printer *p;
|
||
struct isl_obj obj;
|
||
int r = EXIT_SUCCESS;
|
||
|
||
options = cg_options_new_with_defaults();
|
||
assert(options);
|
||
ctx = isl_ctx_alloc_with_options(&options_args, options);
|
||
isl_options_set_ast_build_detect_min_max(ctx, 1);
|
||
argc = cg_options_parse(options, argc, argv, ISL_ARG_ALL);
|
||
|
||
s = isl_stream_new_file(ctx, stdin);
|
||
obj = isl_stream_read_obj(s);
|
||
if (obj.v == NULL) {
|
||
r = EXIT_FAILURE;
|
||
} else if (obj.type == isl_obj_map) {
|
||
isl_union_map *umap;
|
||
|
||
umap = isl_union_map_from_map(obj.v);
|
||
tree = construct_ast_from_union_map(umap, s);
|
||
} else if (obj.type == isl_obj_union_map) {
|
||
tree = construct_ast_from_union_map(obj.v, s);
|
||
} else if (obj.type == isl_obj_schedule) {
|
||
tree = construct_ast_from_schedule(obj.v);
|
||
} else {
|
||
obj.type->free(obj.v);
|
||
isl_die(ctx, isl_error_invalid, "unknown input",
|
||
r = EXIT_FAILURE);
|
||
}
|
||
isl_stream_free(s);
|
||
|
||
p = isl_printer_to_file(ctx, stdout);
|
||
p = isl_printer_set_output_format(p, ISL_FORMAT_C);
|
||
p = isl_printer_print_ast_node(p, tree);
|
||
isl_printer_free(p);
|
||
|
||
isl_ast_node_free(tree);
|
||
|
||
isl_ctx_free(ctx);
|
||
return r;
|
||
}
|