Exemplo n.º 1
0
/* Construct a schedule with "domain" as domain, that executes
 * the elements of "list" in order (as a sequence).
 */
static __isl_give isl_schedule *schedule_from_domain_and_list(
	__isl_keep isl_union_set *domain, __isl_keep isl_union_set_list *list)
{
	isl_schedule *schedule;
	isl_schedule_node *node;

	schedule = isl_schedule_from_domain(isl_union_set_copy(domain));
	node = isl_schedule_get_root(schedule);
	isl_schedule_free(schedule);
	node = isl_schedule_node_child(node, 0);
	list = isl_union_set_list_copy(list);
	node = isl_schedule_node_insert_sequence(node, list);
	schedule = isl_schedule_node_get_schedule(node);
	isl_schedule_node_free(node);

	return schedule;
}
Exemplo n.º 2
0
ast_isl ast_gen::generate()
{
    auto ctx = m_model.context;

    if (verbose<ast_gen>::enabled())
        print_isl_ast_options(ctx);

    if (true)
    {
        //isl_options_set_ast_build_separation_bounds
                //(ctx.get(), ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT);
        //isl_options_set_ast_build_scale_strides(ctx, 0);
    }

    ast_isl output;

    auto build = isl_ast_build_from_context(m_schedule.params.copy());

    if (m_options.separate_loops)
    {
        if (m_schedule.tree.get())
        {
            auto root = isl_schedule_get_root(m_schedule.prelude_tree.get());
            root = mark_loop_type_separate(ctx, root);
            m_schedule.tree = isl_schedule_node_get_schedule(root);
            isl_schedule_node_free(root);
        }

        if (m_schedule.prelude_tree.get())
        {
            auto root = isl_schedule_get_root(m_schedule.prelude_tree.get());
            root = mark_loop_type_separate(ctx, root);

            m_schedule.prelude_tree = isl_schedule_node_get_schedule(root);

            isl_schedule_node_free(root);
        }

        if (m_schedule.period_tree.get())
        {
            auto root = isl_schedule_get_root(m_schedule.period_tree.get());
            root = mark_loop_type_separate(ctx, root);

            m_schedule.period_tree = isl_schedule_node_get_schedule(root);

            isl_schedule_node_free(root);
        }
    }

    build = isl_ast_build_set_before_each_for(build, &ast_gen::invoke_before_for, this);
    build = isl_ast_build_set_after_each_for(build, &ast_gen::invoke_after_for, this);

    // Initialize parallel accesses to empty map
    m_model.parallel_accesses = isl::union_map(m_model.context);

    if (m_schedule.tree.get())
    {
        if (verbose<ast_gen>::enabled())
            cout << endl << "** Building AST for entire program." << endl;
        m_allow_parallel_for = false;
        output.full =
                isl_ast_build_node_from_schedule(build, m_schedule.tree.copy());
    }
    if (m_schedule.prelude_tree.get())
    {
        if (verbose<ast_gen>::enabled())
            cout << endl << "** Building AST for prelude." << endl;
        m_allow_parallel_for = false;
        output.prelude =
                isl_ast_build_node_from_schedule(build, m_schedule.prelude_tree.copy());
    }
    if (m_schedule.period_tree.get())
    {
        if (verbose<ast_gen>::enabled())
            cout << endl << "** Building AST for period." << endl;

        m_allow_parallel_for = m_options.parallel | m_options.vectorize;

        int num_sched_dim = 0;

        m_schedule.period.for_each([&](const isl::map & m){
            num_sched_dim = m.get_space().dimension(isl::space::output);
            return false;
        });

        build = set_loop_iterators(build, num_sched_dim, m_options.parallel_dim);

        output.period =
                isl_ast_build_node_from_schedule(build, m_schedule.period_tree.copy());
    }

    isl_ast_build_free(build);

    return output;
}