#define LPP_SERVER "i44pc52"
#define LPP_SOLVER "cplex"
-#define COST_LOAD 10
+#define COST_LOAD 8
#define COST_STORE 50
#define COST_REMAT 1
+#define LOOP_WEIGHT 12
+
#define ILP_TIMEOUT 120
#define ILP_UNDEF -1
}
static double
-execution_frequency(const spill_ilp_t * si, const ir_node * irn)
+execution_frequency(const ir_node * irn)
{
#define FUDGE 0.001
- if(si->execfreqs) {
- if(is_Block(irn)) {
- return get_block_execfreq(si->execfreqs, irn) + FUDGE;
- } else {
- return get_block_execfreq(si->execfreqs, get_nodes_block(irn)) + FUDGE;
- }
+#ifndef EXECFREQ_LOOPDEPH
+ if(is_Block(irn)) {
+ return get_block_execfreq(irn) + FUDGE;
} else {
- if(is_Block(irn))
- return exp(get_loop_depth(get_irn_loop(irn)) * log(10)) + FUDGE;
- else
- return exp(get_loop_depth(get_irn_loop(get_nodes_block(irn))) * log(10)) + FUDGE;
+ return get_block_execfreq(get_nodes_block(irn)) + FUDGE;
}
+#else
+ if(is_Block(irn))
+ return exp(get_loop_depth(get_irn_loop(irn)) * log(10)) + FUDGE;
+ else
+ return exp(get_loop_depth(get_irn_loop(get_nodes_block(irn))) * log(10)) + FUDGE;
+#endif
}
static double
op->is_remat = 1;
op->attr.remat.remat = remat;
op->attr.remat.pre = 0;
- op->attr.remat.ilp = lpp_add_var(si->lpp, buf, lpp_binary, remat->cost*execution_frequency(si, pos));
+ op->attr.remat.ilp = lpp_add_var(si->lpp, buf, lpp_binary, remat->cost*execution_frequency(pos));
set_irn_link(copy, op);
pset_insert_ptr(si->all_possible_remats, copy);
op->is_remat = 1;
op->attr.remat.remat = remat;
op->attr.remat.pre = 1;
- op->attr.remat.ilp = lpp_add_var(si->lpp, buf, lpp_binary, remat->cost*execution_frequency(si, pos));
+ op->attr.remat.ilp = lpp_add_var(si->lpp, buf, lpp_binary, remat->cost*execution_frequency(pos));
set_irn_link(copy, op);
pset_insert_ptr(si->all_possible_remats, copy);
query.irn = irn;
spill = set_insert(spill_bb->ilp, &query, sizeof(query), HASH_PTR(irn));
- spill_cost = is_Unknown(irn)?0.0001:COST_STORE*execution_frequency(si, bb);
+ spill_cost = is_Unknown(irn)?0.0001:COST_STORE*execution_frequency(bb);
ir_snprintf(buf, sizeof(buf), "reg_out_%N_%N", irn, bb);
spill->reg_out = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
ilp_cst_t rel_cst;
ir_snprintf(buf, sizeof(buf), "reload_%N_%N", bb, irn);
- reload = lpp_add_var(si->lpp, buf, lpp_binary, COST_LOAD*execution_frequency(si, bb));
+ reload = lpp_add_var(si->lpp, buf, lpp_binary, COST_LOAD*execution_frequency(bb));
set_insert_keyval(spill_bb->reloads, irn, INT_TO_PTR(reload));
/* reload <= mem_out */
query.irn = irn;
spill = set_insert(spill_bb->ilp, &query, sizeof(query), HASH_PTR(irn));
- spill_cost = is_Unknown(irn)?0.0001:COST_STORE*execution_frequency(si, bb);
+ spill_cost = is_Unknown(irn)?0.0001:COST_STORE*execution_frequency(bb);
ir_snprintf(buf, sizeof(buf), "reg_out_%N_%N", irn, bb);
spill->reg_out = lpp_add_var(si->lpp, buf, lpp_binary, 0.0);
spill->spill = lpp_add_var(si->lpp, buf, lpp_binary, spill_cost);
ir_snprintf(buf, sizeof(buf), "reload_%N_%N", bb, irn);
- reload = lpp_add_var(si->lpp, buf, lpp_binary, COST_LOAD*execution_frequency(si, bb));
+ reload = lpp_add_var(si->lpp, buf, lpp_binary, COST_LOAD*execution_frequency(bb));
set_insert_keyval(spill_bb->reloads, irn, INT_TO_PTR(reload));
/* reload <= mem_out */
query.irn = irn;
spill = set_find(spill_bb->ilp, &query, sizeof(query), HASH_PTR(irn));
if(!spill) {
- double spill_cost = is_Unknown(irn)?0.0001:COST_STORE*execution_frequency(si, bb);
+ double spill_cost = is_Unknown(irn)?0.0001:COST_STORE*execution_frequency(bb);
spill = set_insert(spill_bb->ilp, &query, sizeof(query), HASH_PTR(irn));
}
}
- ir_snprintf(buf, sizeof(buf), "copyreq_%N_%N", block, to_copy);
+ ir_snprintf(buf, sizeof(buf), "copyreg_%N_%N", block, to_copy);
cst = lpp_add_cst(si->lpp, buf, lpp_less, 0.0);
/* copy - reg_out - copyreg <= 0 */
/* only for values in L\U (TODO and D?), the others are handled with post_use */
if(!pset_find_ptr(used, remat_arg)) {
- /* remat <= live_rang(remat_arg) */
+ /* remat <= live_range(remat_arg) */
ir_snprintf(buf, sizeof(buf), "req_remat2_%N_arg_%N", tmp, remat_arg);
cst = lpp_add_cst(si->lpp, buf, lpp_less, 0.0);
assert(spill);
ir_snprintf(buf, sizeof(buf), "reload_%N_%N", arg, irn);
- op->attr.live_range.args.reloads[i] = lpp_add_var(si->lpp, buf, lpp_binary, COST_LOAD*execution_frequency(si, bb));
+ op->attr.live_range.args.reloads[i] = lpp_add_var(si->lpp, buf, lpp_binary, COST_LOAD*execution_frequency(bb));
/* reload <= mem_out */
ir_snprintf(buf, sizeof(buf), "req_reload_%N_%N", arg, irn);
const ir_node *arg2 = get_irn_n(spill->irn, m);
if(arg==arg2) {
- freq += execution_frequency(si, get_Block_cfgpred_block(bb, m));
+ freq += execution_frequency(get_Block_cfgpred_block(bb, m));
}
}
}
-
-static void
-memcopyinsertor(spill_ilp_t * si)
-{
- /* weise Spillkontexte zu. Sorge bei Phis dafuer, dass gleiche
- * Kontexte zusammenfliessen (Operanden und Ergebnis hat gleichen
- * Kontext)
- */
-
-
-
-
-
-}
-
-
-
-
static INLINE int
is_zero(double x)
{
return 1;
}
+static int
+sched_block_attr_hook(FILE *F, ir_node *node, ir_node *local)
+{
+ if(is_Block(node)) {
+ fprintf(F, " info3:\"execfreq %g\"", execution_frequency(node));
+ }
+
+ return 0;
+}
+
static void
dump_ir_block_graph_sched_pressure(ir_graph *irg, const char *suffix)
{
- DUMP_NODE_EDGE_FUNC old = get_dump_node_edge_hook();
+ DUMP_NODE_EDGE_FUNC old_edge_hook = get_dump_node_edge_hook();
dump_consts_local(0);
+ set_dump_node_vcgattr_hook(sched_block_attr_hook);
set_dump_node_edge_hook(sched_pressure_edge_hook);
dump_ir_block_graph(irg, suffix);
- set_dump_node_edge_hook(old);
+ set_dump_node_vcgattr_hook(NULL);
+ set_dump_node_edge_hook(old_edge_hook);
}
static void
if(!lc_bitset_is_set(kh->used, get_irn_idx(irn))) {
if(be_is_Spill(irn) || be_is_Reload(irn)) {
- DBG((kh->si->dbg, LEVEL_1, "\t SUBOPTIMAL! %+F IS UNUSED (cost: %g)\n", irn, get_cost(kh->si, irn)*execution_frequency(kh->si, bb)));
+ DBG((kh->si->dbg, LEVEL_1, "\t SUBOPTIMAL! %+F IS UNUSED (cost: %g)\n", irn, get_cost(kh->si, irn)*execution_frequency(bb)));
#if 0
assert(lpp_get_sol_state(kh->si->lpp) != lpp_optimal && "optimal solution is suboptimal?");
#endif
si.spills = pset_new_ptr_default();
si.inverse_ops = pset_new_ptr_default();
#ifndef EXECFREQ_LOOPDEPH
- si.execfreqs = compute_execfreq(chordal_env->irg);
+ compute_execfreq(chordal_env->irg, LOOP_WEIGHT);
#else
si.execfreqs = NULL;
#endif
// move reloads upwards
be_liveness(chordal_env->irg);
- //irg_block_walk_graph(chordal_env->irg, walker_pressure_annotator, NULL, &si);
- //move_reloads_upward(&si);
+ irg_block_walk_graph(chordal_env->irg, walker_pressure_annotator, NULL, &si);
+ move_reloads_upward(&si);
#ifndef NO_MEMCOPIES
verify_phiclasses(&si);
del_pset(si.all_possible_remats);
del_pset(si.spills);
#ifndef EXECFREQ_LOOPDEPH
- free_execfreq(si.execfreqs);
+ free_execfreq();
#endif
free_lpp(si.lpp);
obstack_free(&obst, NULL);
projects / libfirm / blobdiff