X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbestat.c;h=847c3b7d9e0a9c77ec54e76fede500bd44959977;hb=501a13c6429ecb1de1cbb274782e67fa0030b970;hp=48336b8f8786c721fe430ab86a55d2cbdfcb8d1e;hpb=e7beaf766b2079cb988bb3532badb9116983f265;p=libfirm diff --git a/ir/be/bestat.c b/ir/be/bestat.c index 48336b8f8..847c3b7d9 100644 --- a/ir/be/bestat.c +++ b/ir/be/bestat.c @@ -1,29 +1,52 @@ +/* + * Copyright (C) 1995-2007 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 "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 */ @@ -88,12 +111,19 @@ static be_stat_irg_t *get_stat_irg_entry(ir_graph *irg) { return entry; } +struct a_pressure_walker { + be_irg_t *birg; + be_lv_t *lv; +}; + /** * 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; +static void stat_reg_pressure_block(ir_node *block, void *data) { + struct a_pressure_walker *env = data; + 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); int i, n = arch_isa_get_n_reg_class(aenv->isa); for (i = 0; i < n; i++) { @@ -102,36 +132,44 @@ static void stat_reg_pressure_block(ir_node *block, void *env) { pset *live_nodes = pset_new_ptr(64); int max_live; - live_nodes = be_liveness_end_of_block(aenv, cls, block, live_nodes); + live_nodes = be_liveness_end_of_block(env->lv, aenv, cls, block, live_nodes); max_live = pset_count(live_nodes); sched_foreach_reverse(block, irn) { int cnt; + if(is_Phi(irn)) + break; + live_nodes = be_liveness_transfer(aenv, cls, irn, live_nodes); cnt = pset_count(live_nodes); - - max_live = cnt < max_live ? max_live : cnt; + max_live = cnt < max_live ? max_live : cnt; } - stat_be_block_regpressure(birg->irg, block, MIN(max_live, 5), cls->name); + stat_be_block_regpressure(irg, block, max_live, cls->name); } } void be_do_stat_reg_pressure(be_irg_t *birg) { + ir_graph *irg = be_get_birg_irg(birg); + if (stat_is_active()) { - be_liveness(birg->irg); + struct a_pressure_walker w; + + w.birg = birg; + w.lv = be_liveness(irg); /* Collect register pressure information for each block */ - irg_block_walk_graph(birg->irg, stat_reg_pressure_block, NULL, birg); + irg_block_walk_graph(irg, stat_reg_pressure_block, NULL, &w); + be_liveness_free(w.lv); } } /** * 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)); } } @@ -157,9 +195,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; @@ -176,7 +215,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; } @@ -184,7 +223,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) @@ -192,23 +231,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++; } /** @@ -293,13 +326,87 @@ void be_stat_init_irg(const arch_env_t *arch_env, ir_graph *irg) { } } } +#endif /* FIRM_STATISTICS */ + +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 + +const char *be_stat_tags[STAT_TAG_LAST]; +FILE *be_stat_file = NULL; + +void be_init_stat_file(const char *stat_file_name, const char *sourcefilename) +{ + static char time_str[32]; + + assert(be_stat_file == NULL); + + /* if we want to do some statistics, push the environment. */ + if (strlen(stat_file_name) == 0) + return; + + be_stat_file = fopen(stat_file_name, "at"); + if (be_stat_file == NULL) { + fprintf(stderr, "Warning couldn't open statfile '%s'\n", stat_file_name); + return; + } + + /* initialize the statistics tags */ + ir_snprintf(time_str, sizeof(time_str),"%u", time(NULL)); + + be_stat_tags[STAT_TAG_FILE] = sourcefilename; + be_stat_tags[STAT_TAG_TIME] = time_str; + be_stat_tags[STAT_TAG_IRG] = ""; + be_stat_tags[STAT_TAG_CLS] = ""; + + be_stat_ev_push(be_stat_tags, STAT_TAG_LAST, be_stat_file); +} + +void be_close_stat_file() +{ + be_stat_ev_pop(); + if (be_stat_file != NULL) { + fclose(be_stat_file); + be_stat_file = NULL; + } +} -#else +#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 */