void cpp_from_isl::process_for(isl_ast_node *node)
{
auto iter_expr = isl_ast_node_for_get_iterator(node);
auto init_expr = isl_ast_node_for_get_init(node);
auto cond_expr = isl_ast_node_for_get_cond(node);
auto inc_expr = isl_ast_node_for_get_inc(node);
auto body_node = isl_ast_node_for_get_body(node);
auto iter = process_expr(iter_expr);
auto init = process_expr(init_expr);
auto cond = process_expr(cond_expr);
auto inc = process_expr(inc_expr);
auto iter_id = dynamic_pointer_cast<id_expression>(iter);
if (!iter_id)
throw error("Iterator expression is not an identifier.");
auto iter_decl = decl_expr(make_shared<basic_type>("int"),
*iter_id, init);
auto for_stmt = make_shared<for_statement>();
for_stmt->initialization = iter_decl;
for_stmt->condition = cond;
for_stmt->update = binop(op::assign_add, iter, inc);
{
vector<statement_ptr> stmts;
m_ctx->push(&stmts);
process_node(body_node);
m_ctx->pop();
if (stmts.size() == 1)
for_stmt->body = stmts.front();
else
for_stmt->body = block(stmts);
}
m_ctx->add(for_stmt);
isl_ast_expr_free(iter_expr);
isl_ast_expr_free(init_expr);
isl_ast_expr_free(cond_expr);
isl_ast_expr_free(inc_expr);
isl_ast_node_free(body_node);
}
instruction_list * isl_for_to_noclock (isl_ast_node * for_node)
{
/* Extract the for loop information. */
isl_ast_expr * iterator = isl_ast_node_for_get_iterator (for_node);
isl_id * id = isl_ast_expr_get_id (iterator);
isl_ast_expr * init = isl_ast_node_for_get_init (for_node);
isl_ast_expr * cond = isl_ast_node_for_get_cond (for_node);
isl_ast_node * body = isl_ast_node_for_get_body (for_node);
/* Construct the for loop. */
instruction * loop = instruction_for_loop (
strdup (isl_id_get_name (id)),
isl_init_to_expr (init),
isl_cond_to_expr (cond),
isl_ast_to_noclock_ast (body));
/* Wrap the loop in an instruction list node. */
instruction_list * list = instruction_list_alloc ();
list->element = loop;
list->next = NULL;
return list;
}
isl_ast_node * ast_gen::after_for(isl_ast_node *node, isl_ast_build * builder)
{
if (verbose<ast_gen>::enabled())
cout << "-- After for" << endl;
bool is_deepest_loop = m_deepest_loop == m_current_loop;
bool is_requested_parallel = false;
{
auto iter_expr = isl_ast_node_for_get_iterator(node);
auto id = isl_ast_expr_get_id(iter_expr);
if (verbose<ast_gen>::enabled())
cout << " Loop iter: " << isl_id_get_name(id) << endl;
auto data = isl_id_get_user(id);
if (data == &m_parallel_loop_id)
{
if (verbose<ast_gen>::enabled())
cout << " Requested as parallel" << endl;
is_requested_parallel = true;
}
id = isl_id_free(id);
isl_ast_expr_free(iter_expr);
}
auto id = isl_ast_node_get_annotation(node);
auto info = ast_node_info::get_from_id(id);
// Mark loop parallel if parallelizable and
// either requested by user or outermost parallizable.
if (!m_options.parallel)
{
if (verbose<ast_gen>::enabled())
cout << " Explicit parallelization not enabled." << endl;
}
else if (!info->is_parallelizable)
{
if (verbose<ast_gen>::enabled())
cout << " Not parallelizable." << endl;
}
else if (m_options.parallel_dim < 0)
{
if (m_num_parallelizable_loops != 1)
{
if (verbose<ast_gen>::enabled())
cout << " Not the outermost parallelizable loop." << endl;
}
else
{
info->is_parallel = true;
}
}
else
{
if (!is_requested_parallel)
{
if (verbose<ast_gen>::enabled())
cout << " Not the requested parallel loop." << endl;
}
else
{
if (verbose<ast_gen>::enabled())
cout << " Parallelized." << endl;
info->is_parallel = true;
}
}
// Mark loop vectorized if parallelizable and deepest.
if (m_options.vectorize && is_deepest_loop && info->is_parallelizable)
{
if (verbose<ast_gen>::enabled())
cout << "-- Loop vectorized." << endl;
info->is_vector = true;
}
if (info->is_parallel || info->is_vector)
{
store_parallel_accesses_for_current_dimension(builder);
}
if (info->is_parallelizable)
--m_num_parallelizable_loops;
--m_current_loop;
id = isl_id_free(id);
return node;
}
