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; }