void *irg_env; /**< An environment for the irg scheduling, provided by the backend */
void *block_env; /**< An environment for scheduling a block, provided by the backend */
const arch_env_t *arch_env;
- const be_main_env_t *main_env;
const be_machine_t *cpu; /**< the current abstract machine */
ilpsched_options_t *opts; /**< the ilp options for current irg */
- const be_irg_t *birg; /**< The birg object */
- be_options_t *be_opts; /**< backend options */
const ilp_sched_selector_t *sel; /**< The ILP sched selector provided by the backend */
DEBUG_ONLY(firm_dbg_module_t *dbg);
} be_ilpsched_env_t;
return QSORT_CMP(n1_a->sched_point, n2_a->sched_point);
}
-/**
- * In case there is no phase information for irn, initialize it.
- */
-static void *init_ilpsched_irn(ir_phase *ph, const ir_node *irn, void *old)
+static void *reinit_ilpsched_irn(ir_phase *ph, const ir_node *irn, void *old)
{
- be_ilpsched_irn_t *res = old ? old : phase_alloc(ph, sizeof(res[0]));
+ be_ilpsched_irn_t *res = old;
- if (res == old) {
- /* if we have already some data: check for reinitialization */
-
- if (! is_Block(irn)) {
- ilpsched_node_attr_t *na = get_ilpsched_node_attr(res);
-
- if (! na->transitive_block_nodes) {
- ir_node *block = get_nodes_block(irn);
- be_ilpsched_irn_t *block_node = phase_get_or_set_irn_data(ph, block);
- ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node);
+ /* if we have already some data: check for reinitialization */
+ if (! is_Block(irn)) {
+ ilpsched_node_attr_t *na = get_ilpsched_node_attr(res);
- /* we are called after the block indices have been build: create bitset */
- na->transitive_block_nodes = bitset_obstack_alloc(phase_obst(ph), ba->block_last_idx);
- }
- else {
- /* we are called from reinit block data: clear the bitset */
- bitset_clear_all(na->transitive_block_nodes);
- na->visit_idx = 0;
- na->alap_changed = 1;
- }
+ if (! na->transitive_block_nodes) {
+ ir_node *block = get_nodes_block(irn);
+ be_ilpsched_irn_t *block_node = phase_get_or_set_irn_data(ph, block);
+ ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node);
+
+ /* we are called after the block indices have been build: create bitset */
+ na->transitive_block_nodes = bitset_obstack_alloc(phase_obst(ph), ba->block_last_idx);
+ } else {
+ /* we are called from reinit block data: clear the bitset */
+ bitset_clear_all(na->transitive_block_nodes);
+ na->visit_idx = 0;
+ na->alap_changed = 1;
}
- return old;
}
+ return res;
+}
+/**
+ * In case there is no phase information for irn, initialize it.
+ */
+static void *init_ilpsched_irn(ir_phase *phase, const ir_node *irn)
+{
+ be_ilpsched_irn_t *res = phase_alloc(phase, sizeof(res[0]));
res->irn = irn;
/* set ilpsched irn attributes (either block or irn) */
ba->head_ilp_nodes = NULL;
ba->livein_nodes = new_pset(cmp_live_in_nodes, 16);
ba->max_steps = 0;
- }
- else {
+ } else {
ilpsched_node_attr_t *na = get_ilpsched_node_attr(res);
memset(na, 0, sizeof(*na));
}
int base_num = ba->n_interesting_nodes * ba->n_interesting_nodes;
int estimated_n_var = (int)((double)base_num * fact_var);
int estimated_n_cst = (int)((double)base_num * fact_cst);
+ be_options_t *options = be_get_irg_options(env->irg);
DBG((env->dbg, LEVEL_1, "Creating LPP with estimated numbers: %d vars, %d cst\n",
estimated_n_var, estimated_n_cst));
create_pressure_alive_constraint(env, lpp, block_node);
}
- DBG((env->dbg, LEVEL_1, "ILP to solve: %u variables, %u constraints\n", lpp->var_next, lpp->cst_next));
+ DBG((env->dbg, LEVEL_1, "ILP to solve: %u variables, %u constraints\n", lpp_get_var_count(lpp), lpp_get_cst_count(lpp)));
/* debug stuff, dump lpp when debugging is on */
DEBUG_ONLY({
}
/* solve the ILP */
- lpp_solve_net(lpp, env->main_env->options->ilp_server, env->main_env->options->ilp_solver);
+ lpp_solve_net(lpp, options->ilp_server, options->ilp_solver);
if (logfile)
fclose(logfile);
}
DBG((env->dbg, LEVEL_1, "\nSolution:\n"));
- DBG((env->dbg, LEVEL_1, "\tsend time: %g sec\n", lpp->send_time / 1000000.0));
- DBG((env->dbg, LEVEL_1, "\treceive time: %g sec\n", lpp->recv_time / 1000000.0));
- DBG((env->dbg, LEVEL_1, "\tmatrix: %u elements, density %.2f%%, size %.2fMB\n", lpp->n_elems, lpp->density, (double)lpp->matrix_mem / 1024.0 / 1024.0));
- DBG((env->dbg, LEVEL_1, "\titerations: %d\n", lpp->iterations));
- DBG((env->dbg, LEVEL_1, "\tsolution time: %g\n", lpp->sol_time));
- DBG((env->dbg, LEVEL_1, "\tobjective function: %g\n", LPP_VALUE_IS_0(lpp->objval) ? 0.0 : lpp->objval));
- DBG((env->dbg, LEVEL_1, "\tbest bound: %g\n", LPP_VALUE_IS_0(lpp->best_bound) ? 0.0 : lpp->best_bound));
-
- DBG((env->dbg, LEVEL_1, "variables used %u bytes\n", obstack_memory_used(&var_obst)));
+ //DBG((env->dbg, LEVEL_1, "\tsend time: %g sec\n", lpp->send_time / 1000000.0));
+ //DBG((env->dbg, LEVEL_1, "\treceive time: %g sec\n", lpp->recv_time / 1000000.0));
+ //DBG((env->dbg, LEVEL_1, "\tmatrix: %u elements, density %.2f%%, size %.2fMB\n", lpp->n_elems, lpp->density, (double)lpp->matrix_mem / 1024.0 / 1024.0));
+ DBG((env->dbg, LEVEL_1, "\titerations: %d\n", lpp_get_iter_cnt(lpp)));
+ DBG((env->dbg, LEVEL_1, "\tsolution time: %g\n", lpp_get_sol_time(lpp)));
+ //DBG((env->dbg, LEVEL_1, "\tobjective function: %g\n", LPP_VALUE_IS_0(lpp->objval) ? 0.0 : lpp->objval));
+ //DBG((env->dbg, LEVEL_1, "\tbest bound: %g\n", LPP_VALUE_IS_0(lpp->best_bound) ? 0.0 : lpp->best_bound));
+
+ //DBG((env->dbg, LEVEL_1, "variables used %u bytes\n", obstack_memory_used(&var_obst)));
}
/* apply solution */
be_stat_ev("nodes", ba->block_last_idx);
- be_stat_ev("vars", lpp ? lpp->var_next : 0);
- be_stat_ev("csts", lpp ? lpp->cst_next : 0);
+ be_stat_ev("vars", lpp ? lpp_get_var_count(lpp) : 0);
+ be_stat_ev("csts", lpp ? lpp_get_cst_count(lpp) : 0);
if (need_heur) {
- be_stat_ev("time", -1);
- be_stat_ev_dbl("opt", 0.0);
- list_sched_single_block(env->birg, block, env->be_opts);
- }
- else {
+ be_stat_ev("time", -1);
+ be_stat_ev_dbl("opt", 0.0);
+ list_sched_single_block(env->irg, block);
+ } else {
+#if 0
if (lpp) {
- double opt = lpp->sol_state == lpp_optimal ? 100.0 : 100.0 * lpp->best_bound / lpp->objval;
+ double opt = lpp_get_sol_state(lpp) == lpp_optimal ? 100.0 : 100.0 * lpp->best_bound / lpp->objval;
be_stat_ev_dbl("time", lpp->sol_time);
be_stat_ev_dbl("opt", opt);
- }
- else {
+ } else {
be_stat_ev_dbl("time", 0.0);
be_stat_ev_dbl("opt", 100.0);
}
+#endif
apply_solution(env, lpp, block);
}
/**
* Perform ILP scheduling on the given irg.
*/
-void be_ilp_sched(const be_irg_t *birg, be_options_t *be_opts)
+void be_ilp_sched(ir_graph *irg)
{
be_ilpsched_env_t env;
- ir_graph *irg = be_get_birg_irg(birg);
const arch_env_t *arch_env = be_get_irg_arch_env(irg);
const ilp_sched_selector_t *sel = arch_env->impl->get_ilp_sched_selector(arch_env);
stat_ev_ctx_push("ilpsched");
-// firm_dbg_set_mask(env.dbg, 1);
-
env.irg_env = be_ilp_sched_init_irg_ilp_schedule(sel, irg);
env.sel = sel;
env.irg = irg;
env.height = heights_new(irg);
- env.main_env = birg->main_env;
env.arch_env = arch_env;
env.cpu = arch_env_get_machine(arch_env);
env.opts = &ilp_opts;
- env.birg = birg;
- env.be_opts = be_opts;
phase_init(&env.ph, env.irg, init_ilpsched_irn);
/* assign a unique per block number to all interesting nodes */
now we can allocate the bitsets (size depends on block indices)
for all nodes.
*/
- phase_reinit_irn_data(&env.ph);
+ phase_reinit_irn_data(&env.ph, reinit_ilpsched_irn);
/* Collect all root nodes (having no user in their block) and calculate ASAP. */
irg_walk_in_or_dep_blkwise_graph(env.irg, collect_alap_root_nodes, calculate_irn_asap, &env);
heights_free(env.height);
/* notify backend */
- be_ilp_sched_finish_irg_ilp_schedule(sel, birg->irg, env.irg_env);
+ be_ilp_sched_finish_irg_ilp_schedule(sel, irg, env.irg_env);
stat_ev_ctx_pop("ilpsched");
}
projects / libfirm / blobdiff