X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbestat.c;h=2c1fe6dfacf87cc49286ef7ee759a664bf37ceb1;hb=1872920c09708b361d06c0dc9f4c1fd0a03544f5;hp=d68480ad552294c5881dd2cee4d21169fd7b1b01;hpb=f436f72951577e35b60e0ea1f2e6a536e4f479bb;p=libfirm diff --git a/ir/be/bestat.c b/ir/be/bestat.c index d68480ad5..2c1fe6dfa 100644 --- a/ir/be/bestat.c +++ b/ir/be/bestat.c @@ -1,29 +1,53 @@ +/* + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * + * This file is part of libFirm. + * + * This file may be distributed and/or modified under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation and appearing in the file LICENSE.GPL included in the + * packaging of this file. + * + * Licensees holding valid libFirm Professional Edition licenses may use + * this file in accordance with the libFirm Commercial License. + * Agreement provided with the Software. + * + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. + */ + /** - * This file calls the corresponding statistic functions for - * some backend statistics. - * @author Christian Wuerdig - * $Id$ + * @file + * @brief Provides several statistic functions for the backend. + * @author Christian Wuerdig + * @version $Id$ */ #ifdef HAVE_CONFIG_H #include "config.h" #endif -#ifdef FIRM_STATISTICS +#include #include "irnode_t.h" #include "irprintf.h" #include "irgwalk.h" #include "irhooks.h" +#include "execfreq.h" #include "dbginfo_t.h" #include "firmstat_t.h" #include "irtools.h" #include "pset.h" +#include "statev.h" +#include "bearch_t.h" #include "bestat.h" #include "belive_t.h" #include "besched.h" #include "benode_t.h" +#ifdef FIRM_STATISTICS + typedef struct _be_stat_irg_t { ir_graph *irg; /**< the irg, the statistic is about */ pset *phases; /**< node statistics for each phase */ @@ -56,6 +80,7 @@ static int cmp_stat_phase(const void *a, const void *b) { static int cmp_stat_data(const void *a, const void *b, size_t len) { const be_stat_irg_t *p1 = a; const be_stat_irg_t *p2 = b; + (void) len; return p1->irg != p2->irg; } @@ -88,53 +113,107 @@ static be_stat_irg_t *get_stat_irg_entry(ir_graph *irg) { return entry; } -/** - * Collect reg pressure statistics per block and per class. - */ -static void stat_reg_pressure_block(ir_node *block, void *env) { - be_irg_t *birg = env; - const arch_env_t *aenv = birg->main_env->arch_env; - int i, n = arch_isa_get_n_reg_class(aenv->isa); +typedef struct pressure_walker_env_t pressure_walker_env_t; +struct pressure_walker_env_t { + be_irg_t *birg; + be_lv_t *lv; + double insn_count; + double regpressure; + int max_pressure; + const arch_register_class_t *cls; +}; + +static void check_reg_pressure_class(pressure_walker_env_t *env, + ir_node *block, + const arch_register_class_t *cls) +{ + be_irg_t *birg = env->birg; + ir_graph *irg = be_get_birg_irg(birg); + const arch_env_t *aenv = be_get_birg_arch_env(birg); + ir_node *irn; + ir_nodeset_t live_nodes; + int max_live; + + ir_nodeset_init(&live_nodes); + be_liveness_end_of_block(env->lv, aenv, cls, block, &live_nodes); + max_live = ir_nodeset_size(&live_nodes); + env->regpressure += max_live; + + sched_foreach_reverse(block, irn) { + int cnt; + + if(is_Phi(irn)) + break; - for (i = 0; i < n; i++) { - const arch_register_class_t *cls = arch_isa_get_reg_class(aenv->isa, i); - ir_node *irn; - pset *live_nodes = pset_new_ptr(64); - int max_live; + be_liveness_transfer(aenv, cls, irn, &live_nodes); + cnt = ir_nodeset_size(&live_nodes); + max_live = cnt < max_live ? max_live : cnt; + env->regpressure += cnt; + env->insn_count++; + } - live_nodes = be_liveness_end_of_block(aenv, cls, block, live_nodes); - max_live = pset_count(live_nodes); + if(max_live > env->max_pressure) + env->max_pressure = max_live; - sched_foreach_reverse(block, irn) { - int cnt; + stat_be_block_regpressure(irg, block, max_live, cls->name); + ir_nodeset_destroy(&live_nodes); +} - if(is_Phi(irn)) - break; +/** + * Collect reg pressure statistics per block and per class. + */ +static void stat_reg_pressure_block(ir_node *block, void *data) { + pressure_walker_env_t *env = data; - live_nodes = be_liveness_transfer(aenv, cls, irn, live_nodes); - cnt = pset_count(live_nodes); + if(env->cls != NULL) { + check_reg_pressure_class(env, block, env->cls); + } else { + const arch_env_t *arch_env = be_get_birg_arch_env(env->birg); + int i, n; - max_live = cnt < max_live ? max_live : cnt; - } + n = arch_env_get_n_reg_class(arch_env); + for (i = 0; i < n; i++) { + const arch_register_class_t *cls + = arch_env_get_reg_class(arch_env, i); - stat_be_block_regpressure(birg->irg, block, MIN(max_live, 5), cls->name); + check_reg_pressure_class(env, block, cls); + } } } void be_do_stat_reg_pressure(be_irg_t *birg) { - if (stat_is_active()) { - be_liveness(birg->irg); - /* Collect register pressure information for each block */ - irg_block_walk_graph(birg->irg, stat_reg_pressure_block, NULL, birg); - } + pressure_walker_env_t env; + ir_graph *irg = be_get_birg_irg(birg); + double average_pressure; + + env.birg = birg; + env.insn_count = 0; + env.max_pressure = 0; + env.regpressure = 0; + be_liveness_assure_sets(be_assure_liveness(birg)); + env.lv = be_get_birg_liveness(birg); + + // hack for now, TODO: remove me later +#if 0 + env.cls = NULL; +#else + env.cls = arch_env_get_reg_class(be_get_birg_arch_env(birg), 2); +#endif + + /* Collect register pressure information for each block */ + irg_block_walk_graph(irg, stat_reg_pressure_block, NULL, &env); + + average_pressure = env.regpressure / env.insn_count; + stat_ev_emit("average_register_pressure", average_pressure); + stat_ev_emit("maximum_register_pressure", env.max_pressure); } /** * Notify statistic module about amount of ready nodes. */ -void be_do_stat_sched_ready(ir_node *block, nodeset *ready_set) { +void be_do_stat_sched_ready(ir_node *block, const ir_nodeset_t *ready_set) { if (stat_is_active()) { - stat_be_block_sched_ready(get_irn_irg(block), block, nodeset_count(ready_set)); + stat_be_block_sched_ready(get_irn_irg(block), block, MIN(ir_nodeset_size(ready_set), 5)); } } @@ -160,9 +239,10 @@ void be_do_stat_permcycle(const char *class_name, ir_node *perm, ir_node *block, * Updates nodes statistics. */ static void do_nodes_stat(ir_node *irn, void *env) { - be_stat_phase_t *phase = env; - ir_mode *mode; - opcode opc; + be_stat_phase_t *phase = env; + ir_mode *mode; + ir_opcode opc; + arch_irn_class_t irn_class; if (is_Block(irn)) return; @@ -179,7 +259,7 @@ static void do_nodes_stat(ir_node *irn, void *env) { opc == iro_End) return; - if (is_Proj(irn)) { + if (is_Proj(irn) && (mode != mode_X)) { phase->num_proj++; return; } @@ -187,7 +267,7 @@ static void do_nodes_stat(ir_node *irn, void *env) { phase->num_phi++; return; } - else if (mode_is_datab(mode) || (mode == mode_T && ! is_be_node(irn))) + else if (mode_is_datab(mode) || ((mode == mode_T) && ! is_be_node(irn)) || (is_Proj(irn) && (mode == mode_X))) phase->num_data++; if (opc == iro_Load) @@ -195,23 +275,17 @@ static void do_nodes_stat(ir_node *irn, void *env) { else if (opc == iro_Store) phase->num_store++; - switch (arch_irn_classify(phase->arch_env, irn)) { - case arch_irn_class_spill: - phase->num_spill++; - break; - case arch_irn_class_reload: - phase->num_reload++; - break; - case arch_irn_class_stackparam: - case arch_irn_class_load: - phase->num_load++; - break; - case arch_irn_class_store: - phase->num_store++; - break; - default: - break; - } + irn_class = arch_irn_classify(phase->arch_env, irn); + if (irn_class & arch_irn_class_spill) + phase->num_spill++; + else if (irn_class & arch_irn_class_reload) + phase->num_reload++; + else if (irn_class & arch_irn_class_stackparam) + phase->num_load++; + else if (irn_class & arch_irn_class_load) + phase->num_load++; + else if (irn_class & arch_irn_class_store) + phase->num_store++; } /** @@ -296,13 +370,49 @@ void be_stat_init_irg(const arch_env_t *arch_env, ir_graph *irg) { } } } +#endif /* FIRM_STATISTICS */ -#else +typedef struct _estimate_irg_costs_env_t { + const arch_env_t *arch_env; + ir_exec_freq *execfreqs; + double costs; +} estimate_irg_costs_env_t; + +static void estimate_block_costs(ir_node *block, void *data) +{ + estimate_irg_costs_env_t *env = data; + ir_node *node; + double costs = 0.0; + + sched_foreach(block, node) { + costs += arch_get_op_estimated_cost(env->arch_env, node); + } + + env->costs += costs * get_block_execfreq(env->execfreqs, block); +} + +double be_estimate_irg_costs(ir_graph *irg, const arch_env_t *arch_env, ir_exec_freq *execfreqs) +{ + estimate_irg_costs_env_t env; + + env.arch_env = arch_env; + env.execfreqs = execfreqs; + env.costs = 0.0; + + irg_block_walk_graph(irg, estimate_block_costs, NULL, &env); + + return env.costs; +} + +#ifdef FIRM_STATISTICS + + +#else /* FIRM_STATISTICS */ void (be_stat_init_irg)(const arch_env_t *arch_env, ir_graph *irg) {} void (be_do_stat_nodes)(ir_graph *irg, const char *phase) {} void (be_do_stat_reg_pressure)(be_irg_t *birg) {} -void (be_do_stat_sched_ready)(ir_node *block, nodeset *ready_set) {} +void (be_do_stat_sched_ready)(ir_node *block, ir_nodeset_t *ready_set) {} void (be_do_stat_perm)(const char *class_name, int n_regs, ir_node *perm, ir_node *block, int n, int real_size) {} #endif /* FIRM_STATISTICS */