From 75b78dc47d9f1310e0f07bc306b314e89bc5c50c Mon Sep 17 00:00:00 2001 From: Sebastian Buchwald Date: Sun, 6 Sep 2009 21:31:36 +0000 Subject: [PATCH] Use module mechanism to register copy minimization algorithms. [r26498] --- ir/be/becopyheur.c | 18 ++++++++- ir/be/becopyheur2.c | 31 +++++++++------ ir/be/becopyheur4.c | 10 ++++- ir/be/becopyilp2.c | 12 ++++++ ir/be/becopyopt.c | 96 ++++++++++++++++----------------------------- ir/be/becopyopt.h | 28 ++++++++----- ir/be/becopypbqp.c | 14 ++++++- ir/be/bemodule.c | 15 +++++-- 8 files changed, 131 insertions(+), 93 deletions(-) diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c index ca7fc8bb9..5e8805ff7 100644 --- a/ir/be/becopyheur.c +++ b/ir/be/becopyheur.c @@ -43,6 +43,7 @@ #include "becopystat.h" #include "beintlive_t.h" #include "beirg.h" +#include "bemodule.h" DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) @@ -616,9 +617,12 @@ static void ou_optimize(unit_t *ou) { free_qnode(curr); } +/** + * Solves the problem using a heuristic approach + * Uses the OU data structure + */ int co_solve_heuristic(copy_opt_t *co) { unit_t *curr; - FIRM_DBG_REGISTER(dbg, "ir.be.copyoptheur"); ASSERT_OU_AVAIL(co); @@ -630,3 +634,15 @@ int co_solve_heuristic(copy_opt_t *co) { del_pset(pinned_global); return 0; } + +void be_init_copyheur(void) +{ + static co_algo_info copyheur = { + co_solve_heuristic, 0 + }; + + be_register_copyopt("heur1", ©heur); + FIRM_DBG_REGISTER(dbg, "ir.be.copyoptheur"); +} + +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur); diff --git a/ir/be/becopyheur2.c b/ir/be/becopyheur2.c index 5b163cda7..8764628b1 100644 --- a/ir/be/becopyheur2.c +++ b/ir/be/becopyheur2.c @@ -84,18 +84,6 @@ static const lc_opt_table_entry_t options[] = { LC_OPT_LAST }; -void be_init_copyheur2(void) -{ - lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be"); - lc_opt_entry_t *ra_grp = lc_opt_get_grp(be_grp, "ra"); - lc_opt_entry_t *chordal_grp = lc_opt_get_grp(ra_grp, "chordal"); - lc_opt_entry_t *co2_grp = lc_opt_get_grp(chordal_grp, "co2"); - - lc_opt_add_table(co2_grp, options); -} - -BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur2); - /* ____ _ _ / ___|| |_ __ _ _ __| |_ @@ -1236,7 +1224,6 @@ static be_ifg_dump_dot_cb_t ifg_dot_cb = { ifg_dump_at_end }; - int co_solve_heuristic_new(copy_opt_t *co) { char buf[256]; @@ -1277,3 +1264,21 @@ int co_solve_heuristic_new(copy_opt_t *co) phase_free(&env.ph); return 0; } + +void be_init_copyheur2(void) +{ + lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be"); + lc_opt_entry_t *ra_grp = lc_opt_get_grp(be_grp, "ra"); + lc_opt_entry_t *chordal_grp = lc_opt_get_grp(ra_grp, "chordal"); + lc_opt_entry_t *co2_grp = lc_opt_get_grp(chordal_grp, "co2"); + + lc_opt_add_table(co2_grp, options); + + static co_algo_info copyheur = { + co_solve_heuristic_new, 0 + }; + + be_register_copyopt("heur2", ©heur); +} + +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur2); diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c index 76a19306f..7d0509854 100644 --- a/ir/be/becopyheur4.c +++ b/ir/be/becopyheur4.c @@ -1381,7 +1381,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { /** * Main driver for mst safe coalescing algorithm. */ -int co_solve_heuristic_mst(copy_opt_t *co) { +static int co_solve_heuristic_mst(copy_opt_t *co) { unsigned n_regs = co->cls->n_regs; bitset_t *ignore_regs = bitset_alloca(n_regs); unsigned i, j, k; @@ -1482,8 +1482,14 @@ void be_init_copyheur4(void) { lc_opt_entry_t *heur4_grp = lc_opt_get_grp(co_grp, "heur4"); lc_opt_add_table(heur4_grp, options); + + static co_algo_info copyheur = { + co_solve_heuristic_mst, 0 + }; + + be_register_copyopt("heur4", ©heur); + FIRM_DBG_REGISTER(dbg, "firm.be.co.heur4"); } - BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4); diff --git a/ir/be/becopyilp2.c b/ir/be/becopyilp2.c index 2dd2ae572..52a36f6c9 100644 --- a/ir/be/becopyilp2.c +++ b/ir/be/becopyilp2.c @@ -57,6 +57,7 @@ #include "becopyilp_t.h" #include "beifg_t.h" #include "besched.h" +#include "bemodule.h" #define DEBUG_LVL 1 @@ -539,6 +540,17 @@ static void ilp2_apply(ilp_env_t *ienv) { #endif } +void be_init_copyilp2(void) +{ + static co_algo_info copyheur = { + co_solve_ilp2, 1 + }; + + be_register_copyopt("ilp", ©heur); +} + +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyilp2); + int co_solve_ilp2(copy_opt_t *co) { lpp_sol_state_t sol_state; ilp_env_t *ienv; diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c index b9b1aa24b..ce7eed75a 100644 --- a/ir/be/becopyopt.c +++ b/ir/be/becopyopt.c @@ -77,7 +77,6 @@ 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 unsigned algo = CO_ALGO_HEUR4; static int improve = 1; static const lc_opt_enum_mask_items_t dump_items[] = { @@ -97,18 +96,6 @@ static const lc_opt_enum_mask_items_t style_items[] = { { NULL, 0 } }; -static const lc_opt_enum_mask_items_t algo_items[] = { - { "none", CO_ALGO_NONE }, - { "heur", CO_ALGO_HEUR }, - { "heur2", CO_ALGO_HEUR2 }, - { "heur4", CO_ALGO_HEUR4 }, - { "ilp", CO_ALGO_ILP }, -#ifdef FIRM_KAPS - { "pbqp", CO_ALGO_PBQP }, -#endif - { NULL, 0 } -}; - typedef int (*opt_funcptr)(void); static const lc_opt_enum_func_ptr_items_t cost_func_items[] = { @@ -126,16 +113,11 @@ static lc_opt_enum_mask_var_t style_var = { &style_flags, style_items }; -static lc_opt_enum_mask_var_t algo_var = { - &algo, algo_items -}; - static lc_opt_enum_func_ptr_var_t cost_func_var = { (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", &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), @@ -144,6 +126,16 @@ static const lc_opt_table_entry_t options[] = { LC_OPT_LAST }; +static be_module_list_entry_t *copyopts = NULL; +static const co_algo_info *selected_copyopt = NULL; + +void be_register_copyopt(const char *name, co_algo_info *copyopt) +{ + if (selected_copyopt == NULL) + selected_copyopt = copyopt; + be_add_module_to_list(©opts, name, copyopt); +} + void be_init_copyopt(void) { lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be"); @@ -152,9 +144,28 @@ void be_init_copyopt(void) lc_opt_entry_t *co_grp = lc_opt_get_grp(chordal_grp, "co"); lc_opt_add_table(co_grp, options); + be_add_module_list_opt(co_grp, "algo", "select copy optimization algo", + ©opts, (void**) &selected_copyopt); +} + +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyopt); + +static int void_algo(copy_opt_t *co) +{ + (void) co; + return 0; +} + +void be_init_copynone(void) +{ + static co_algo_info copyheur = { + void_algo, 0 + }; + + be_register_copyopt("none", ©heur); } -BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copycoal); +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copynone); #undef QUICK_AND_DIRTY_HACK @@ -1079,43 +1090,6 @@ void co_solve_park_moon(copy_opt_t *opt) (void) opt; } -static int void_algo(copy_opt_t *co) -{ - (void) co; - return 0; -} - -/* - _ _ _ _ _ - / \ | | __ _ ___ _ __(_) |_| |__ _ __ ___ ___ - / _ \ | |/ _` |/ _ \| '__| | __| '_ \| '_ ` _ \/ __| - / ___ \| | (_| | (_) | | | | |_| | | | | | | | \__ \ - /_/ \_\_|\__, |\___/|_| |_|\__|_| |_|_| |_| |_|___/ - |___/ -*/ - -typedef struct { - co_algo_t *algo; - const char *name; - int can_improve_existing; -} co_algo_info_t; - -static const co_algo_info_t algos[] = { - { void_algo, "none", 0 }, - { co_solve_heuristic, "heur1", 0 }, - { co_solve_heuristic_new, "heur2", 0 }, - { co_solve_heuristic_mst, "heur4", 0 }, -#ifdef WITH_ILP - { co_solve_ilp2, "ilp", 1 }, -#else - { NULL, "ilp", 1 }, -#endif -#ifdef FIRM_KAPS - { co_solve_heuristic_pbqp, "pbqp", 0 }, -#endif - { NULL, "", 0 } -}; - /* __ __ _ ____ _ | \/ | __ _(_)_ __ | _ \ _ __(_)_ _____ _ __ @@ -1155,11 +1129,9 @@ void co_driver(be_chordal_env_t *cenv) ir_timer_t *timer = ir_timer_register("firm.be.copyopt", "runtime"); co_complete_stats_t before, after; copy_opt_t *co; - co_algo_t *algo_func; int was_optimal = 0; - if (algo >= CO_ALGO_LAST) - return; + assert(selected_copyopt); be_liveness_assure_chk(be_get_birg_liveness(cenv->birg)); @@ -1185,7 +1157,7 @@ void co_driver(be_chordal_env_t *cenv) } /* if the algo can improve results, provide an initial solution with heur1 */ - if (improve && algos[algo].can_improve_existing) { + if (improve && selected_copyopt->can_improve_existing) { co_complete_stats_t stats; /* produce a heuristic solution */ @@ -1196,11 +1168,9 @@ void co_driver(be_chordal_env_t *cenv) be_stat_ev_ull("co_prepare_costs", stats.costs); } - algo_func = algos[algo].algo; - /* perform actual copy minimization */ ir_timer_reset_and_start(timer); - was_optimal = algo_func(co); + was_optimal = selected_copyopt->copyopt(co); ir_timer_stop(timer); be_stat_ev("co_time", ir_timer_elapsed_msec(timer)); diff --git a/ir/be/becopyopt.h b/ir/be/becopyopt.h index 6ef7863cb..ba94d50f5 100644 --- a/ir/be/becopyopt.h +++ b/ir/be/becopyopt.h @@ -63,13 +63,28 @@ enum { CO_ALGO_LAST }; -/** The driver for copy minimization. */ -void co_driver(be_chordal_env_t *cenv); - typedef struct _copy_opt_t copy_opt_t; typedef int(*cost_fct_t)(const copy_opt_t *, ir_node *, ir_node *, int); +typedef struct { + int (*copyopt)(copy_opt_t *co); /**< function ptr to run copyopt */ + int can_improve_existing; +} co_algo_info; + + +/** + * Register a new copy optimazation algorithm. + * + * @param name the name of the copy optimazation algorithm, + * used to select it + * @param spiller a copy optimazation entry + */ +void be_register_copyopt(const char *name, co_algo_info *copyopt); + +/** The driver for copy minimization. */ +void co_driver(be_chordal_env_t *cenv); + /** A coalescing algorithm. */ typedef int (co_algo_t)(copy_opt_t *); @@ -157,11 +172,6 @@ void co_solve_park_moon(copy_opt_t *co); */ int co_solve_heuristic_new(copy_opt_t *co); -/** - * This is the pure C implementation of co_solve_heuristic_java(). - */ -int co_solve_heuristic_mst(copy_opt_t *co); - /** * Returns the maximal costs possible, i.e. the costs if all * pairs would be assigned different registers. @@ -241,8 +251,6 @@ int co_solve_ilp1(copy_opt_t *co, double time_limit); */ int co_solve_ilp2(copy_opt_t *co); -int co_solve_heuristic_pbqp(copy_opt_t *co); - /** * Checks if a node is optimizable, viz has something to do with coalescing. * Uses the GRAPH data structure diff --git a/ir/be/becopypbqp.c b/ir/be/becopypbqp.c index 0b633ddda..609149a9a 100644 --- a/ir/be/becopypbqp.c +++ b/ir/be/becopypbqp.c @@ -19,6 +19,7 @@ #include "becopyopt_t.h" #include "beifg.h" #include "beifg_t.h" +#include "bemodule.h" #include "irprintf_t.h" #include "error.h" @@ -49,7 +50,7 @@ static FILE *my_open(const be_chordal_env_t *env, const char *prefix, const char return result; } -int co_solve_heuristic_pbqp(copy_opt_t *co) { +static int co_solve_heuristic_pbqp(copy_opt_t *co) { void *nodes_it = be_ifg_nodes_iter_alloca(co->cenv->ifg); void *neigh_it = be_ifg_neighbours_iter_alloca(co->cenv->ifg); ir_node *ifg_node, *if_neighb_node; @@ -217,4 +218,15 @@ int co_solve_heuristic_pbqp(copy_opt_t *co) { return 0; } +void be_init_copypbqp(void) +{ + static co_algo_info copyheur = { + co_solve_heuristic_pbqp, 0 + }; + + be_register_copyopt("pbqp", ©heur); +} + +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copypbqp); + #endif diff --git a/ir/be/bemodule.c b/ir/be/bemodule.c index 0861b7ff0..4a0356896 100644 --- a/ir/be/bemodule.c +++ b/ir/be/bemodule.c @@ -40,9 +40,11 @@ void be_init_schedrss(void); void be_init_chordal(void); void be_init_chordal_main(void); void be_init_copyopt(void); +void be_init_copyheur(void); void be_init_copyheur2(void); void be_init_copyheur4(void); -void be_init_copyheur5(void); +void be_init_copyilp2(void); +void be_init_copypbqp(void); void be_init_copystat(void); void be_init_daemelspill(void); void be_init_dbgout(void); @@ -99,9 +101,16 @@ void be_init_modules(void) be_init_chordal_main(); be_init_chordal(); be_init_copyopt(); - be_init_copyheur2(); be_init_copyheur4(); -// be_init_copyheur5(); + be_init_copyheur(); + be_init_copyheur2(); +#ifdef WITH_ILP + be_init_copyilp2(); +#endif +#ifdef FIRM_KAPS + be_init_copypbqp(); +#endif + be_init_copynone(); be_init_copystat(); be_init_peephole(); be_init_ra(); -- 2.20.1