From: Daniel Grund Date: Mon, 1 Aug 2005 14:06:14 +0000 (+0000) Subject: fixed bugs in statistic. adapted to critical edges. X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=b9776d1f90b9376855ea7f3f875ce22e65b39272;p=libfirm fixed bugs in statistic. adapted to critical edges. --- diff --git a/ir/be/becopyilp.c b/ir/be/becopyilp.c index b3c1206a4..7beba8a6f 100644 --- a/ir/be/becopyilp.c +++ b/ir/be/becopyilp.c @@ -618,8 +618,8 @@ static void pi_apply_solution(problem_instance_t *pi) { DBG((dbg, LEVEL_2, "Applying solution...\n")); #ifdef DO_STAT - curr_vals[I_ILP_ITER] += lpp_get_iter_cnt(pi->curr_lp); - curr_vals[I_ILP_TIME] += lpp_get_sol_time(pi->curr_lp); + copystat_add_ilp_time(lpp_get_sol_time(pi->curr_lp)); + copystat_add_ilp_iter(lpp_get_iter_cnt(pi->curr_lp)); #endif sol = xmalloc((pi->last_x_var+1) * sizeof(*sol)); diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c index c4c2fe589..8a94a763b 100644 --- a/ir/be/becopyopt.c +++ b/ir/be/becopyopt.c @@ -121,6 +121,7 @@ static void co_append_unit(copy_opt_t *co, ir_node *root) { assert(is_curr_reg_class(arg) && "Argument not in same register class."); if (arg == root) continue; + /* TODO or arg live at root.*/ if (nodes_interfere(co->chordal_env, root, arg)) { unit->inevitable_costs += co->get_costs(root, arg, i); continue; @@ -262,6 +263,27 @@ int get_costs_all_one(ir_node *root, ir_node* arg, int pos) { return 1; } +int co_get_max_copy_costs(const copy_opt_t *co) { + int i, res = 0; + unit_t *curr; + + list_for_each_entry(unit_t, curr, &co->units, units) { + res += curr->inevitable_costs; + for (i=1; inode_count; ++i) + res += curr->costs[i]; + } + return res; +} + +int co_get_inevit_copy_costs(const copy_opt_t *co) { + int res = 0; + unit_t *curr; + + list_for_each_entry(unit_t, curr, &co->units, units) + res += curr->inevitable_costs; + return res; +} + int co_get_copy_costs(const copy_opt_t *co) { int i, res = 0; unit_t *curr; diff --git a/ir/be/becopyopt.h b/ir/be/becopyopt.h index 3b56cf434..620893110 100644 --- a/ir/be/becopyopt.h +++ b/ir/be/becopyopt.h @@ -129,6 +129,18 @@ int get_costs_loop_depth(ir_node *root, ir_node* arg, int pos); */ int get_costs_all_one(ir_node *root, ir_node* arg, int pos); +/** + * Returns the maximal costs possible, i.e. the costs if all + * pairs would be assigned different registers. + */ +int co_get_max_copy_costs(const copy_opt_t *co); + +/** + * Returns the inevitable costs, i.e. the costs of + * all copy pairs which interfere. + */ +int co_get_inevit_copy_costs(const copy_opt_t *co); + /** * Returns the current costs the copies are causing. * The result includes inevitable costs and the costs diff --git a/ir/be/becopyoptmain.c b/ir/be/becopyoptmain.c index e1be7a88d..839318427 100644 --- a/ir/be/becopyoptmain.c +++ b/ir/be/becopyoptmain.c @@ -33,7 +33,8 @@ void be_copy_opt(be_chordal_env_t *chordal_env) { copy_opt_t *co; int lb, copy_costs; - /* BETTER: You can remove this if you replace all `grep get_irn_out *.c`*/ + /* BETTER: You can remove this if you replace all + * `grep get_irn_out *.c` by the irouts.h module.*/ compute_outs(chordal_env->session_env->irg); co = new_copy_opt(chordal_env, get_costs_loop_depth); @@ -42,7 +43,9 @@ void be_copy_opt(be_chordal_env_t *chordal_env) { #ifdef DO_STAT lb = co_get_lower_bound(co); copy_costs = co_get_copy_costs(co); - curr_vals[I_COPIES_INIT] += copy_costs; + copystat_add_max_costs(co_get_max_copy_costs(co)); + copystat_add_inevit_costs(co_get_inevit_copy_costs(co)); + copystat_add_init_costs(copy_costs); DBG((dbg, LEVEL_1, "Init costs: %3d <= %3d\n", lb, copy_costs)); #endif @@ -50,7 +53,7 @@ void be_copy_opt(be_chordal_env_t *chordal_env) { co_heur_opt(co); #ifdef DO_STAT copy_costs = co_get_copy_costs(co); - curr_vals[I_COPIES_HEUR] += copy_costs; + copystat_add_heur_costs(copy_costs); DBG((dbg, LEVEL_1, "Heur costs: %3d <= %3d\n", lb, copy_costs)); #endif #endif @@ -60,13 +63,12 @@ void be_copy_opt(be_chordal_env_t *chordal_env) { assert(copy_costs>=lb && "At least one computation of these two is boooogy"); if (copy_costs > lb) { co_ilp_opt(co); - be_ra_chordal_check(chordal_env); } #ifdef DO_STAT copy_costs = co_get_copy_costs(co); assert(copy_costs>=lb && "At least one computation of these two is boooogy"); - curr_vals[I_COPIES_OPT] += copy_costs; + copystat_add_opt_costs(copy_costs); DBG((dbg, LEVEL_1, "Opt costs: %3d <= %3d\n", lb, copy_costs)); #endif #endif diff --git a/ir/be/becopystat.c b/ir/be/becopystat.c index 24a1c7836..d48e09bd6 100644 --- a/ir/be/becopystat.c +++ b/ir/be/becopystat.c @@ -21,6 +21,60 @@ #define DEBUG_LVL 0 //SET_LEVEL_1 static firm_dbg_module_t *dbg = NULL; +#define MAX_ARITY 10 +#define MAX_CLS_SIZE 10 +#define MAX_CLS_PHIS 10 +#define MAX_PHASE 2 + +/** + * For an explanation of these values see the code of copystat_dump_pretty + */ +enum vals_t { + I_ALL_NODES = 0, + I_BLOCKS, + + /* phi nodes */ + I_PHI_CNT, /* number of phi nodes */ + I_PHI_ARG_CNT, /* number of arguments of phis */ + I_PHI_ARG_SELF, /* number of arguments of phis being the phi itself */ + I_PHI_ARG_CONST, /* number of arguments of phis being consts */ + I_PHI_ARG_PRED, /* ... being defined in a cf-pred */ + I_PHI_ARG_GLOB, /* ... being defined elsewhere */ + I_PHI_ARITY_S, + I_PHI_ARITY_E = I_PHI_ARITY_S+MAX_ARITY, + + /* copy nodes */ + I_CPY_CNT, /* number of copynodes */ + + /* phi classes */ + I_CLS_CNT, /* number of phi classes */ + I_CLS_IF_FREE, /* number of pc having no interference */ + I_CLS_IF_MAX, /* number of possible interferences in all classes */ + I_CLS_IF_CNT, /* number of actual interferences in all classes */ + I_CLS_SIZE_S, + I_CLS_SIZE_E = I_CLS_SIZE_S+MAX_CLS_SIZE, + I_CLS_PHIS_S, + I_CLS_PHIS_E = I_CLS_PHIS_S+MAX_CLS_PHIS, + + /* ilp values */ + I_ILP_TIME, /* !external set! solving time in seconds */ + I_ILP_ITER, /* !external set! number of simplex iterations */ + + /* copy instructions */ + I_COPIES_MAX, /* !external set! max possible costs of copies*/ + I_COPIES_INIT, /* !external set! number of copies in initial allocation */ + I_COPIES_HEUR, /* !external set! number of copies after heuristic */ + I_COPIES_OPT, /* !external set! number of copies after ilp */ + I_COPIES_IF, /* number of copies inevitable due to root-arg-interf */ + + ASIZE +}; + +/** + * Holds current values. Values are added till next copystat_reset + */ +int curr_vals[ASIZE]; + static pset *all_phi_nodes; static pset *all_phi_classes; static pset *all_copy_nodes; @@ -91,16 +145,7 @@ static void stat_phi_node(be_chordal_env_t *chordal_env, ir_node *phi) { /* type of argument {self, const, pred, glob} */ for (i = 0; i < arity; i++) { ir_node *block_of_arg, *block_ith_pred; - ir_node *arg = get_irn_n(phi, i); - - if (phi != arg) { - curr_vals[I_COPIES_MAX]++; /* if arg!=phi this is a possible copy */ - if (nodes_interfere(chordal_env, phi, arg)) { - DBG((dbg, LEVEL_1, "%e -- In Block %N: %n %N %n %N\n", - get_irg_entity(chordal_env->session_env->irg), get_nodes_block(phi), phi, phi, arg, arg)); - curr_vals[I_COPIES_IF]++; - } - } + ir_node *cfg_node, *arg = get_irn_n(phi, i); if (arg == phi) { curr_vals[I_PHI_ARG_SELF]++; @@ -112,8 +157,17 @@ static void stat_phi_node(be_chordal_env_t *chordal_env, ir_node *phi) { continue; } - block_of_arg = get_Block_cfgpred_block(get_nodes_block(phi), i); - block_ith_pred = get_nodes_block(get_irn_n(get_nodes_block(phi), i)); + block_of_arg = get_nodes_block(arg); + + /* get the pred block skipping blocks on critical edges */ + cfg_node = get_irn_n(get_nodes_block(phi), i); + block_ith_pred = get_nodes_block(cfg_node); + if (get_irn_opcode(cfg_node) == iro_Jmp && get_irn_arity(block_ith_pred) == 1) { + /* Then cfg_node_block has exactly 1 pred and 1 succ block, + * thus it must have been inserted during remove_critical_edges */ + block_ith_pred = get_Block_cfgpred_block(block_ith_pred, 0); + } + if (block_of_arg == block_ith_pred) { curr_vals[I_PHI_ARG_PRED]++; continue; @@ -208,6 +262,28 @@ void copystat_collect_cls(be_chordal_env_t *chordal_env) { } } +void copystat_add_max_costs(int costs) { + curr_vals[I_COPIES_MAX] += costs; +} +void copystat_add_inevit_costs(int costs) { + curr_vals[I_COPIES_IF] += costs; +} +void copystat_add_init_costs(int costs) { + curr_vals[I_COPIES_INIT] += costs; +} +void copystat_add_heur_costs(int costs) { + curr_vals[I_COPIES_HEUR] += costs; +} +void copystat_add_opt_costs(int costs) { + curr_vals[I_COPIES_OPT] += costs; +} +void copystat_add_ilp_time(int time) { + curr_vals[I_ILP_TIME] += time; +} +void copystat_add_ilp_iter(int iters) { + curr_vals[I_ILP_ITER] += iters; +} + void copystat_dump(ir_graph *irg) { int i; char buf[1024]; diff --git a/ir/be/becopystat.h b/ir/be/becopystat.h index 3d6ddc40c..8f465afc0 100644 --- a/ir/be/becopystat.h +++ b/ir/be/becopystat.h @@ -8,68 +8,24 @@ #define _BECOPYSTAT_H #define DO_STAT + #ifdef DO_STAT #include "irgraph.h" - -#define MAX_ARITY 10 -#define MAX_CLS_SIZE 10 -#define MAX_CLS_PHIS 10 -#define MAX_PHASE 2 - -/** - * For an explanation of these values see the code of copystat_dump_pretty - */ -enum vals_t { - I_ALL_NODES = 0, - I_BLOCKS, - - /* phi nodes */ - I_PHI_CNT, /* number of phi nodes */ - I_PHI_ARG_CNT, /* number of arguments of phis */ - I_PHI_ARG_SELF, /* number of arguments of phis being the phi itself */ - I_PHI_ARG_CONST, /* number of arguments of phis being consts */ - I_PHI_ARG_PRED, /* ... being defined in a cf-pred */ - I_PHI_ARG_GLOB, /* ... being defined elsewhere */ - I_PHI_ARITY_S, - I_PHI_ARITY_E = I_PHI_ARITY_S+MAX_ARITY, - - /* copy nodes */ - I_CPY_CNT, /* number of copynodes */ - - /* phi classes */ - I_CLS_CNT, /* number of phi classes */ - I_CLS_IF_FREE, /* number of pc having no interference */ - I_CLS_IF_MAX, /* number of possible interferences in all classes */ - I_CLS_IF_CNT, /* number of actual interferences in all classes */ - I_CLS_SIZE_S, - I_CLS_SIZE_E = I_CLS_SIZE_S+MAX_CLS_SIZE, - I_CLS_PHIS_S, - I_CLS_PHIS_E = I_CLS_PHIS_S+MAX_CLS_PHIS, - - /* ilp values */ - I_ILP_TIME, /* !external set! solving time in seconds */ - I_ILP_ITER, /* !external set! number of simplex iterations */ - - /* copy instructions */ - I_COPIES_MAX, /* max number of copies possible */ - I_COPIES_INIT, /* !external set! number of copies in initial allocation */ - I_COPIES_HEUR, /* !external set! number of copies after heuristic */ - I_COPIES_OPT, /* !external set! number of copies after ilp */ - I_COPIES_IF, /* number of copies inevitable due to root-arg-interf */ - - ASIZE -}; - -/** - * Holds current values. Values are added till next copystat_reset - */ -int curr_vals[ASIZE]; +#include "bearch.h" +#include "bechordal_t.h" void copystat_init(void); void copystat_reset(void); void copystat_collect_irg(ir_graph *irg, arch_env_t *arch_env); void copystat_collect_cls(be_chordal_env_t *chordal_env); +void copystat_add_max_costs(int costs); +void copystat_add_inevit_costs(int costs); +void copystat_add_init_costs(int costs); +void copystat_add_heur_costs(int costs); +void copystat_add_opt_costs(int costs); +void copystat_add_ilp_time(int time); +void copystat_add_ilp_iter(int iters); void copystat_dump(ir_graph *irg); void copystat_dump_pretty(ir_graph *irg); @@ -79,6 +35,13 @@ void copystat_dump_pretty(ir_graph *irg); #define copystat_reset(); #define copystat_collect_irg(irg, arch_env); #define copystat_collect_cls(env); +#define copystat_add_max_costs(costs); +#define copystat_add_inevit_costs(costs); +#define copystat_add_init_costs(costs); +#define copystat_add_heur_costs(costs); +#define copystat_add_opt_costs(costs); +#define copystat_add_ilp_time(int time); +#define copystat_add_ilp_iter(int iters); #define copystat_dump(irg); #define copystat_dump(irg); #define copystat_dump_pretty(irg);