X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbestat.c;h=2c1fe6dfacf87cc49286ef7ee759a664bf37ceb1;hb=1894b7dd99b524c25c8fa18c33c250ea2cde2e36;hp=8ac3d6dba06b4ac1c4c2ef4ef24c6d08ae1f9ca9;hpb=a4cf97f91f44fcb14d08f9295bcdef8da372a54d;p=libfirm diff --git a/ir/be/bestat.c b/ir/be/bestat.c index 8ac3d6dba..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,62 +113,107 @@ static be_stat_irg_t *get_stat_irg_entry(ir_graph *irg) { return entry; } -struct a_pressure_walker { +typedef struct pressure_walker_env_t pressure_walker_env_t; +struct pressure_walker_env_t { be_irg_t *birg; - be_lv_t *lv; + 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; + + 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++; + } + + if(max_live > env->max_pressure) + env->max_pressure = max_live; + + stat_be_block_regpressure(irg, block, max_live, cls->name); + ir_nodeset_destroy(&live_nodes); +} + /** * Collect reg pressure statistics per block and per class. */ static void stat_reg_pressure_block(ir_node *block, void *data) { - struct a_pressure_walker *env = data; - be_irg_t *birg = env->birg; - const arch_env_t *aenv = birg->main_env->arch_env; - int i, n = arch_isa_get_n_reg_class(aenv->isa); - - 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; - - live_nodes = be_liveness_end_of_block(env->lv, aenv, cls, block, live_nodes); - max_live = pset_count(live_nodes); + pressure_walker_env_t *env = data; - sched_foreach_reverse(block, irn) { - int cnt; + 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; - if(is_Phi(irn)) - break; + 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); - live_nodes = be_liveness_transfer(aenv, cls, irn, live_nodes); - cnt = pset_count(live_nodes); - max_live = cnt < max_live ? max_live : cnt; + check_reg_pressure_class(env, block, cls); } - - stat_be_block_regpressure(birg->irg, block, max_live, cls->name); } } void be_do_stat_reg_pressure(be_irg_t *birg) { - if (stat_is_active()) { - struct a_pressure_walker w; + 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 - w.birg = birg; - w.lv = be_liveness(birg->irg); - /* Collect register pressure information for each block */ - irg_block_walk_graph(birg->irg, stat_reg_pressure_block, NULL, &w); - be_liveness_free(w.lv); - } + /* 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, MIN(nodeset_count(ready_set), 5)); + stat_be_block_sched_ready(get_irn_irg(block), block, MIN(ir_nodeset_size(ready_set), 5)); } } @@ -171,7 +241,7 @@ void be_do_stat_permcycle(const char *class_name, ir_node *perm, ir_node *block, static void do_nodes_stat(ir_node *irn, void *env) { be_stat_phase_t *phase = env; ir_mode *mode; - opcode opc; + ir_opcode opc; arch_irn_class_t irn_class; if (is_Block(irn)) @@ -300,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 */