nsz Git - libfirm/blob - ir/be/bestat.c

   1 /*
   2  * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief       Provides several statistic functions for the backend.
  23  * @author      Christian Wuerdig, Matthias Braun
  24  * @version     $Id$
  25  */
  26 #include "config.h"
  27
  28 #include <time.h>
  29
  30 #include "irnode_t.h"
  31 #include "irprintf.h"
  32 #include "irgwalk.h"
  33 #include "irhooks.h"
  34 #include "execfreq.h"
  35 #include "firmstat_t.h"
  36 #include "irtools.h"
  37 #include "statev.h"
  38 #include "error.h"
  39
  40 #include "bearch.h"
  41 #include "beirg.h"
  42 #include "bestat.h"
  43 #include "belive_t.h"
  44 #include "besched.h"
  45 #include "benode.h"
  46
  47
  48
  49 typedef struct pressure_walker_env_t pressure_walker_env_t;
  50 struct pressure_walker_env_t {
  51         ir_graph *irg;
  52         be_lv_t  *lv;
  53         double    insn_count;
  54         double    regpressure;
  55         size_t    max_pressure;
  56         const arch_register_class_t *cls;
  57 };
  58
  59 static void check_reg_pressure_class(pressure_walker_env_t *env,
  60                                      ir_node *block,
  61                                      const arch_register_class_t *cls)
  62 {
  63         ir_graph     *irg  = env->irg;
  64         ir_node      *irn;
  65         ir_nodeset_t  live_nodes;
  66         size_t        max_live;
  67
  68         ir_nodeset_init(&live_nodes);
  69         be_liveness_end_of_block(env->lv, cls, block, &live_nodes);
  70         max_live = ir_nodeset_size(&live_nodes);
  71         env->regpressure += max_live;
  72
  73         sched_foreach_reverse(block, irn) {
  74                 size_t cnt;
  75
  76                 if (is_Phi(irn))
  77                         break;
  78
  79                 be_liveness_transfer(cls, irn, &live_nodes);
  80                 cnt      = ir_nodeset_size(&live_nodes);
  81                 max_live = cnt < max_live ? max_live : cnt;
  82                 env->regpressure += cnt;
  83                 env->insn_count++;
  84         }
  85
  86         if (max_live > env->max_pressure)
  87                 env->max_pressure = max_live;
  88
  89         stat_be_block_regpressure(irg, block, max_live, cls->name);
  90         ir_nodeset_destroy(&live_nodes);
  91 }
  92
  93 static void stat_reg_pressure_block(ir_node *block, void *data)
  94 {
  95         pressure_walker_env_t *env = (pressure_walker_env_t*)data;
  96
  97         check_reg_pressure_class(env, block, env->cls);
  98 }
  99
 100 void be_do_stat_reg_pressure(ir_graph *irg, const arch_register_class_t *cls)
 101 {
 102         pressure_walker_env_t  env;
 103         double                 average_pressure;
 104
 105         env.irg          = irg;
 106         env.insn_count   = 0;
 107         env.max_pressure = 0;
 108         env.regpressure  = 0;
 109         be_liveness_assure_sets(be_assure_liveness(irg));
 110         env.lv           = be_get_irg_liveness(irg);
 111         env.cls          = cls;
 112
 113         /* Collect register pressure information for each block */
 114         irg_block_walk_graph(irg, stat_reg_pressure_block, NULL, &env);
 115
 116         average_pressure = env.regpressure / env.insn_count;
 117         stat_ev_emit("bechordal_average_register_pressure", average_pressure);
 118         stat_ev_emit("bechordal_maximum_register_pressure", env.max_pressure);
 119 }
 120
 121
 122
 123
 124 typedef struct estimate_irg_costs_env_t {
 125         ir_exec_freq     *execfreqs;
 126         double           costs;
 127 } estimate_irg_costs_env_t;
 128
 129 static void estimate_block_costs(ir_node *block, void *data)
 130 {
 131         estimate_irg_costs_env_t *env = (estimate_irg_costs_env_t*)data;
 132         ir_node *node;
 133         double  costs = 0.0;
 134
 135         sched_foreach(block, node) {
 136                 costs += arch_get_op_estimated_cost(node);
 137         }
 138
 139         env->costs += costs * get_block_execfreq(env->execfreqs, block);
 140 }
 141
 142 double be_estimate_irg_costs(ir_graph *irg, ir_exec_freq *execfreqs)
 143 {
 144         estimate_irg_costs_env_t env;
 145
 146         env.execfreqs = execfreqs;
 147         env.costs     = 0.0;
 148
 149         irg_block_walk_graph(irg, estimate_block_costs, NULL, &env);
 150
 151         return env.costs;
 152 }
 153
 154
 155
 156 static void node_stat_walker(ir_node *irn, void *data)
 157 {
 158         be_node_stats_t *const stats = (be_node_stats_t*)data;
 159
 160         /* if the node is a normal phi */
 161         if (is_Phi(irn)) {
 162                 if (get_irn_mode(irn) == mode_M) {
 163                         (*stats)[BE_STAT_MEM_PHIS]++;
 164                 } else {
 165                         (*stats)[BE_STAT_PHIS]++;
 166                 }
 167         } else if (!is_Proj(irn)) {
 168                 arch_irn_class_t classify = arch_irn_classify(irn);
 169
 170                 if (classify & arch_irn_class_spill)
 171                         (*stats)[BE_STAT_SPILLS]++;
 172                 if (classify & arch_irn_class_reload)
 173                         (*stats)[BE_STAT_RELOADS]++;
 174                 if (classify & arch_irn_class_remat)
 175                         (*stats)[BE_STAT_REMATS]++;
 176                 if (classify & arch_irn_class_copy)
 177                         (*stats)[BE_STAT_COPIES]++;
 178                 if (classify & arch_irn_class_perm)
 179                         (*stats)[BE_STAT_PERMS]++;
 180         }
 181 }
 182
 183 void be_collect_node_stats(be_node_stats_t *new_stats, ir_graph *irg)
 184 {
 185         memset(new_stats, 0, sizeof(*new_stats));
 186         irg_walk_graph(irg, NULL, node_stat_walker, new_stats);
 187 }
 188
 189 void be_subtract_node_stats(be_node_stats_t *stats, be_node_stats_t *sub)
 190 {
 191         int i;
 192         for (i = 0; i < BE_STAT_COUNT; ++i) {
 193                 (*stats)[i] -= (*sub)[i];
 194         }
 195 }
 196
 197 void be_copy_node_stats(be_node_stats_t *dest, be_node_stats_t *src)
 198 {
 199         memcpy(dest, src, sizeof(be_node_stats_t));
 200 }
 201
 202 static const char *get_stat_name(enum be_stat_tag_t tag)
 203 {
 204         switch (tag) {
 205         case BE_STAT_PHIS:     return "phis";
 206         case BE_STAT_MEM_PHIS: return "mem_phis";
 207         case BE_STAT_COPIES:   return "copies";
 208         case BE_STAT_PERMS:    return "perms";
 209         case BE_STAT_SPILLS:   return "spills";
 210         case BE_STAT_RELOADS:  return "reloads";
 211         case BE_STAT_REMATS:   return "remats";
 212         default:               panic("unknown stat tag found");
 213         }
 214 }
 215
 216 void be_emit_node_stats(be_node_stats_t *stats, const char *prefix)
 217 {
 218         static char   buf[256];
 219         be_stat_tag_t i;
 220
 221         for (i = BE_STAT_FIRST; i < BE_STAT_COUNT; ++i) {
 222                 snprintf(buf, sizeof(buf), "%s%s", prefix, get_stat_name(i));
 223                 stat_ev_dbl(buf, (*stats)[i]);
 224         }
 225 }
 226
 227
 228
 229 static void insn_count_walker(ir_node *irn, void *data)
 230 {
 231         unsigned long *cnt = (unsigned long*)data;
 232
 233         switch (get_irn_opcode(irn)) {
 234         case iro_Proj:
 235         case iro_Phi:
 236         case beo_Start:
 237         case iro_End:
 238                 break;
 239         default:
 240                 (*cnt)++;
 241         }
 242 }
 243
 244 unsigned long be_count_insns(ir_graph *irg)
 245 {
 246         unsigned long cnt = 0;
 247         irg_walk_graph(irg, insn_count_walker, NULL, &cnt);
 248         return cnt;
 249 }
 250
 251 static void block_count_walker(ir_node *node, void *data)
 252 {
 253         unsigned long *cnt = (unsigned long*)data;
 254         if (node == get_irg_end_block(current_ir_graph))
 255                 return;
 256         (*cnt)++;
 257 }
 258
 259 unsigned long be_count_blocks(ir_graph *irg)
 260 {
 261         unsigned long cnt = 0;
 262         irg_block_walk_graph(irg, block_count_walker, NULL, &cnt);
 263         return cnt;
 264 }