X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyopt.c;h=685f60189d9c0246b81971dd2a03da23f301577c;hb=48f0393daa5d5a14ed7e3e32ee2b090759c9371e;hp=b206eaa8e74a75d9452cc8b61cfd0536c142c09a;hpb=839487dfb4a714fa7e66063495ade6a3726040ef;p=libfirm diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c index b206eaa8e..685f60189 100644 --- a/ir/be/becopyopt.c +++ b/ir/be/becopyopt.c @@ -39,6 +39,13 @@ #include "beinsn_t.h" #include "besched_t.h" #include "benodesets.h" +#include "bejavacoal.h" +#include "bestatevent.h" + +#ifdef WITH_LIBCORE +#include +#include +#endif /* WITH_LIBCORE */ #define DUMP_BEFORE 1 #define DUMP_AFTER 2 @@ -49,11 +56,12 @@ #define COST_FUNC_LOOP 2 #define COST_FUNC_ALL_ONE 3 -static int dump_flags = 0; -static int style_flags = 0; -static int do_stats = 0; +static unsigned dump_flags = 0; +static unsigned style_flags = 0; +static unsigned do_stats = 0; static cost_fct_t cost_func = co_get_costs_exec_freq; static int algo = CO_ALGO_HEUR2; +static int improve = 1; #ifdef WITH_LIBCORE static const lc_opt_enum_mask_items_t dump_items[] = { @@ -77,16 +85,22 @@ static const lc_opt_enum_mask_items_t algo_items[] = { { "none", CO_ALGO_NONE }, { "heur", CO_ALGO_HEUR }, { "heur2", CO_ALGO_HEUR2 }, +#ifdef WITH_JVM { "heur3", CO_ALGO_HEUR3 }, +#endif /* WITH_JVM */ +#ifdef WITH_ILP { "ilp", CO_ALGO_ILP }, +#endif /* WITH_ILP */ { NULL, 0 } }; +typedef int (*opt_funcptr)(void); + static const lc_opt_enum_func_ptr_items_t cost_func_items[] = { - { "freq", co_get_costs_exec_freq }, - { "loop", co_get_costs_loop_depth }, - { "one", co_get_costs_all_one }, - { NULL, 0 } + { "freq", (opt_funcptr) co_get_costs_exec_freq }, + { "loop", (opt_funcptr) co_get_costs_loop_depth }, + { "one", (opt_funcptr) co_get_costs_all_one }, + { NULL, NULL } }; static lc_opt_enum_mask_var_t dump_var = { @@ -102,15 +116,16 @@ static lc_opt_enum_mask_var_t algo_var = { }; static lc_opt_enum_func_ptr_var_t cost_func_var = { - &cost_func, cost_func_items + (opt_funcptr*) &cost_func, cost_func_items }; static const lc_opt_table_entry_t options[] = { - LC_OPT_ENT_ENUM_INT ("algo", "select copy optimization algo (heur, heur2, heur3, ilp)", &algo_var), - LC_OPT_ENT_ENUM_FUNC_PTR ("cost", "select a cost function (freq, loop, one)", &cost_func_var), - LC_OPT_ENT_ENUM_MASK ("dump", "dump ifg before or after copy optimization", &dump_var), - LC_OPT_ENT_ENUM_MASK ("style", "dump style for ifg dumping", &style_var), - LC_OPT_ENT_BOOL ("stats", "dump statistics after each optimization", &do_stats), + LC_OPT_ENT_ENUM_INT ("algo", "select copy optimization algo", &algo_var), + LC_OPT_ENT_ENUM_FUNC_PTR ("cost", "select a cost function", &cost_func_var), + LC_OPT_ENT_ENUM_MASK ("dump", "dump ifg before or after copy optimization", &dump_var), + LC_OPT_ENT_ENUM_MASK ("style", "dump style for ifg dumping", &style_var), + LC_OPT_ENT_BOOL ("stats", "dump statistics after each optimization", &do_stats), + LC_OPT_ENT_BOOL ("improve", "run heur3 before if algo can exploit start solutions", &improve), { NULL } }; @@ -147,6 +162,7 @@ void co_register_options(lc_opt_entry_t *grp) DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) + void be_copy_opt_init(void) { } @@ -244,18 +260,21 @@ int co_get_costs_loop_depth(const copy_opt_t *co, ir_node *root, ir_node* arg, i int d = get_loop_depth(loop); cost = d*d; } - return cost+1; + return 1+cost; } int co_get_costs_exec_freq(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos) { + int res; ir_node *root_bl = get_nodes_block(root); ir_node *copy_bl = is_Phi(root) ? get_Block_cfgpred_block(root_bl, pos) : root_bl; - unsigned long freq = get_block_execfreq_ulong(co->cenv->exec_freq, copy_bl); - return freq > 0 ? (int) freq : 1; + res = get_block_execfreq_ulong(co->cenv->exec_freq, copy_bl); + + /* don't allow values smaller than one. */ + return res < 1 ? 1 : res; } -int co_get_costs_all_one(const copy_opt_t *co, ir_node *root, ir_node* arg, int pos) { +int co_get_costs_all_one(const copy_opt_t *co, ir_node *root, ir_node *arg, int pos) { return 1; } @@ -631,6 +650,40 @@ int co_get_lower_bound(const copy_opt_t *co) { return res; } +void co_complete_stats(const copy_opt_t *co, co_complete_stats_t *stat) +{ + bitset_t *seen = bitset_irg_malloc(co->irg); + affinity_node_t *an; + + memset(stat, 0, sizeof(stat[0])); + + /* count affinity edges. */ + co_gs_foreach_aff_node(co, an) { + neighb_t *neigh; + stat->aff_nodes += 1; + bitset_add_irn(seen, an->irn); + co_gs_foreach_neighb(an, neigh) { + if(!bitset_contains_irn(seen, neigh->irn)) { + stat->aff_edges += 1; + stat->max_costs += neigh->costs; + + if(get_irn_col(co, an->irn) != get_irn_col(co, neigh->irn)) { + stat->costs += neigh->costs; + stat->unsatisfied_edges += 1; + } + + if(nodes_interfere(co->cenv, an->irn, neigh->irn)) { + stat->aff_int += 1; + stat->inevit_costs += neigh->costs; + } + + } + } + } + + bitset_free(seen); +} + /****************************************************************************** _____ _ _____ _ / ____| | | / ____| | @@ -815,7 +868,7 @@ void co_dump_appel_graph(const copy_opt_t *co, FILE *f) if(!arch_irn_is(co->aenv, n->irn, ignore)) { int n_idx = PTR_TO_INT(get_irn_link(n->irn)); if(idx < n_idx) - fprintf(f, "%d %d %d\n", idx, n_idx, n->costs); + fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs); } } } @@ -1261,7 +1314,7 @@ static void ifg_dump_at_end(FILE *file, void *self) if(env->flags & CO_IFG_DUMP_COLORS) fprintf(file, "color=%s ", color); else - fprintf(file, "style=dashed"); + fprintf(file, "style=dotted"); fprintf(file, "];\n"); } } @@ -1309,14 +1362,21 @@ static int void_algo(copy_opt_t *co) |___/ */ -static co_algo_t *algos[] = { - void_algo, - co_solve_heuristic, - co_solve_heuristic_new, - co_solve_heuristic_java, +typedef struct { + co_algo_t *algo; + const char *name; + int can_improve_existing; +} co_algo_info_t; + +static co_algo_info_t algos[] = { + { void_algo, "none", 0 }, + { co_solve_heuristic, "heur1", 0 }, + { co_solve_heuristic_new, "heur2", 0 }, + { co_solve_heuristic_java, "heur3", 0 }, #ifdef WITH_ILP - co_solve_ilp2 + { co_solve_ilp2, "ilp", 1 }, #endif + { NULL, "", 0 } }; /* @@ -1330,9 +1390,13 @@ static co_algo_t *algos[] = { void co_driver(be_chordal_env_t *cenv) { +#ifdef WITH_LIBCORE + lc_timer_t *timer = lc_timer_register("firm.be.copyopt", "runtime"); +#endif + co_complete_stats_t before, after; copy_opt_t *co; co_algo_t *algo_func; - int init_costs; + int was_optimal = 0; if(algo < 0 || algo >= CO_ALGO_LAST) return; @@ -1340,7 +1404,17 @@ void co_driver(be_chordal_env_t *cenv) co = new_copy_opt(cenv, cost_func); co_build_ou_structure(co); co_build_graph_structure(co); - init_costs = co_get_copy_costs(co); + + co_complete_stats(co, &before); + + be_stat_ev_ull("co_aff_nodes", before.aff_nodes); + be_stat_ev_ull("co_aff_edges", before.aff_edges); + be_stat_ev_ull("co_max_costs", before.max_costs); + be_stat_ev_ull("co_inevit_costs", before.inevit_costs); + be_stat_ev_ull("co_aff_int", before.aff_int); + + be_stat_ev_ull("co_init_costs", before.costs); + be_stat_ev_ull("co_init_unsat", before.unsatisfied_edges); /* Dump the interference graph in Appel's format. */ if(dump_flags & DUMP_APPEL) { @@ -1355,8 +1429,38 @@ void co_driver(be_chordal_env_t *cenv) fclose(f); } - algo_func = algos[algo]; - algo_func(co); + /* if the algo can improve results, provide an initial solution with heur3 */ + if(improve && algos[algo].can_improve_existing) { + co_complete_stats_t stats; + + /* produce a heuristical solution */ + co_solve_heuristic_java(co); + + /* do the stats and provide the current costs */ + co_complete_stats(co, &stats); + be_stat_ev_ull("co_prepare_costs", stats.costs); + } + +#ifdef WITH_JVM + /* start the JVM here so that it does not tamper the timing. */ + if(algo == CO_ALGO_HEUR3) + be_java_coal_start_jvm(); +#endif + + algo_func = algos[algo].algo; + +#ifdef WITH_LIBCORE + lc_timer_reset_and_start(timer); +#endif + + was_optimal = algo_func(co); + +#ifdef WITH_LIBCORE + lc_timer_stop(timer); + be_stat_ev("co_time", lc_timer_elapsed_msec(timer)); +#endif + + be_stat_ev_ull("co_optimal", was_optimal); if(dump_flags & DUMP_AFTER) { FILE *f = be_chordal_open(cenv, "", "-after.dot"); @@ -1364,21 +1468,24 @@ void co_driver(be_chordal_env_t *cenv) fclose(f); } + co_complete_stats(co, &after); + if(do_stats) { - int optimizable_costs = co_get_max_copy_costs(co) - co_get_lower_bound(co); - int remaining = co_get_copy_costs(co); - int evitable = remaining - co_get_lower_bound(co); + ulong64 optimizable_costs = after.max_costs - after.inevit_costs; + ulong64 evitable = after.costs - after.inevit_costs; - ir_printf("%30F %10s %10d%10d%10d%10d", cenv->irg, cenv->cls->name, - co_get_max_copy_costs(co), init_costs, - co_get_inevit_copy_costs(co), co_get_lower_bound(co)); + ir_printf("%30F ", cenv->irg); + printf("%10s %10" ULL_FMT "%10" ULL_FMT "%10" ULL_FMT, cenv->cls->name, after.max_costs, before.costs, after.inevit_costs); if(optimizable_costs > 0) - printf("%10d %5.2f\n", remaining, (evitable * 100.0) / optimizable_costs); + printf("%10" ULL_FMT " %5.2f\n", after.costs, (evitable * 100.0) / optimizable_costs); else - printf("%10d %5s\n", remaining, "-"); + printf("%10" ULL_FMT " %5s\n", after.costs, "-"); } + be_stat_ev_ull("co_after_costs", after.costs); + be_stat_ev_ull("co_after_unsat", after.unsatisfied_edges); + co_free_graph_structure(co); co_free_ou_structure(co); free_copy_opt(co);