gcc/statistics.c

   1 /* Optimization statistics functions.
   2    Copyright (C) 2008-2013 Free Software Foundation, Inc.
   3    Contributed by Richard Guenther  <rguenther@suse.de>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tree-pass.h"
  25 #include "tree-dump.h"
  26 #include "statistics.h"
  27 #include "hash-table.h"
  28 #include "function.h"
  29 #include "context.h"
  30 #include "pass_manager.h"
  31
  32 static int statistics_dump_nr;
  33 static int statistics_dump_flags;
  34 static FILE *statistics_dump_file;
  35
  36 /* Statistics entry.  A integer counter associated to a string ID
  37    and value.  */
  38
  39 typedef struct statistics_counter_s {
  40   const char *id;
  41   int val;
  42   bool histogram_p;
  43   unsigned HOST_WIDE_INT count;
  44   unsigned HOST_WIDE_INT prev_dumped_count;
  45 } statistics_counter_t;
  46
  47 /* Hashtable helpers.  */
  48
  49 struct stats_counter_hasher
  50 {
  51   typedef statistics_counter_t value_type;
  52   typedef statistics_counter_t compare_type;
  53   static inline hashval_t hash (const value_type *);
  54   static inline bool equal (const value_type *, const compare_type *);
  55   static inline void remove (value_type *);
  56 };
  57
  58 /* Hash a statistic counter by its string ID.  */
  59
  60 inline hashval_t
  61 stats_counter_hasher::hash (const value_type *c)
  62 {
  63   return htab_hash_string (c->id) + c->val;
  64 }
  65
  66 /* Compare two statistic counters by their string IDs.  */
  67
  68 inline bool
  69 stats_counter_hasher::equal (const value_type *c1, const compare_type *c2)
  70 {
  71   return c1->val == c2->val && strcmp (c1->id, c2->id) == 0;
  72 }
  73
  74 /* Free a statistics entry.  */
  75
  76 inline void
  77 stats_counter_hasher::remove (value_type *v)
  78 {
  79   free (CONST_CAST(char *, v->id));
  80   free (v);
  81 }
  82
  83 typedef hash_table <stats_counter_hasher> stats_counter_table_type;
  84
  85 /* Array of statistic hashes, indexed by pass id.  */
  86 static stats_counter_table_type *statistics_hashes;
  87 static unsigned nr_statistics_hashes;
  88
  89 /* Return the current hashtable to be used for recording or printing
  90    statistics.  */
  91
  92 static stats_counter_table_type
  93 curr_statistics_hash (void)
  94 {
  95   unsigned idx;
  96
  97   gcc_assert (current_pass->static_pass_number >= 0);
  98   idx = current_pass->static_pass_number;
  99
 100   if (idx < nr_statistics_hashes
 101       && statistics_hashes[idx].is_created ())
 102     return statistics_hashes[idx];
 103
 104   if (idx >= nr_statistics_hashes)
 105     {
 106       statistics_hashes = XRESIZEVEC (stats_counter_table_type,
 107                                       statistics_hashes, idx+1);
 108       memset (statistics_hashes + nr_statistics_hashes, 0,
 109               (idx + 1 - nr_statistics_hashes)
 110               * sizeof (stats_counter_table_type));
 111       nr_statistics_hashes = idx + 1;
 112     }
 113
 114   statistics_hashes[idx].create (15);
 115
 116   return statistics_hashes[idx];
 117 }
 118
 119 /* Helper for statistics_fini_pass.  Print the counter difference
 120    since the last dump for the pass dump files.  */
 121
 122 int
 123 statistics_fini_pass_1 (statistics_counter_t **slot,
 124                         void *data ATTRIBUTE_UNUSED)
 125 {
 126   statistics_counter_t *counter = *slot;
 127   unsigned HOST_WIDE_INT count = counter->count - counter->prev_dumped_count;
 128   if (count == 0)
 129     return 1;
 130   if (counter->histogram_p)
 131     fprintf (dump_file, "%s == %d: " HOST_WIDE_INT_PRINT_DEC "\n",
 132              counter->id, counter->val, count);
 133   else
 134     fprintf (dump_file, "%s: " HOST_WIDE_INT_PRINT_DEC "\n",
 135              counter->id, count);
 136   counter->prev_dumped_count = counter->count;
 137   return 1;
 138 }
 139
 140 /* Helper for statistics_fini_pass.  Print the counter difference
 141    since the last dump for the statistics dump.  */
 142
 143 int
 144 statistics_fini_pass_2 (statistics_counter_t **slot,
 145                         void *data ATTRIBUTE_UNUSED)
 146 {
 147   statistics_counter_t *counter = *slot;
 148   unsigned HOST_WIDE_INT count = counter->count - counter->prev_dumped_count;
 149   if (count == 0)
 150     return 1;
 151   counter->prev_dumped_count = counter->count;
 152   if (counter->histogram_p)
 153     fprintf (statistics_dump_file,
 154              "%d %s \"%s == %d\" \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n",
 155              current_pass->static_pass_number,
 156              current_pass->name,
 157              counter->id, counter->val,
 158              current_function_name (),
 159              count);
 160   else
 161     fprintf (statistics_dump_file,
 162              "%d %s \"%s\" \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n",
 163              current_pass->static_pass_number,
 164              current_pass->name,
 165              counter->id,
 166              current_function_name (),
 167              count);
 168   counter->prev_dumped_count = counter->count;
 169   return 1;
 170 }
 171
 172 /* Helper for statistics_fini_pass, reset the counters.  */
 173
 174 int
 175 statistics_fini_pass_3 (statistics_counter_t **slot,
 176                         void *data ATTRIBUTE_UNUSED)
 177 {
 178   statistics_counter_t *counter = *slot;
 179   counter->prev_dumped_count = counter->count;
 180   return 1;
 181 }
 182
 183 /* Dump the current statistics incrementally.  */
 184
 185 void
 186 statistics_fini_pass (void)
 187 {
 188   if (current_pass->static_pass_number == -1)
 189     return;
 190
 191   if (dump_file
 192       && dump_flags & TDF_STATS)
 193     {
 194       fprintf (dump_file, "\n");
 195       fprintf (dump_file, "Pass statistics:\n");
 196       fprintf (dump_file, "----------------\n");
 197       curr_statistics_hash ()
 198         .traverse_noresize <void *, statistics_fini_pass_1> (NULL);
 199       fprintf (dump_file, "\n");
 200     }
 201   if (statistics_dump_file
 202       && !(statistics_dump_flags & TDF_STATS
 203            || statistics_dump_flags & TDF_DETAILS))
 204     curr_statistics_hash ()
 205       .traverse_noresize <void *, statistics_fini_pass_2> (NULL);
 206   curr_statistics_hash ()
 207     .traverse_noresize <void *, statistics_fini_pass_3> (NULL);
 208 }
 209
 210 /* Helper for printing summary information.  */
 211
 212 int
 213 statistics_fini_1 (statistics_counter_t **slot, opt_pass *pass)
 214 {
 215   statistics_counter_t *counter = *slot;
 216   if (counter->count == 0)
 217     return 1;
 218   if (counter->histogram_p)
 219     fprintf (statistics_dump_file,
 220              "%d %s \"%s == %d\" " HOST_WIDE_INT_PRINT_DEC "\n",
 221              pass->static_pass_number,
 222              pass->name,
 223              counter->id, counter->val,
 224              counter->count);
 225   else
 226     fprintf (statistics_dump_file,
 227              "%d %s \"%s\" " HOST_WIDE_INT_PRINT_DEC "\n",
 228              pass->static_pass_number,
 229              pass->name,
 230              counter->id,
 231              counter->count);
 232   return 1;
 233 }
 234
 235 /* Finish the statistics and dump summary information.  */
 236
 237 void
 238 statistics_fini (void)
 239 {
 240   gcc::pass_manager *passes = g->get_passes ();
 241   if (!statistics_dump_file)
 242     return;
 243
 244   if (statistics_dump_flags & TDF_STATS)
 245     {
 246       unsigned i;
 247       for (i = 0; i < nr_statistics_hashes; ++i)
 248         if (statistics_hashes[i].is_created ()
 249             && passes->get_pass_for_id (i) != NULL)
 250           statistics_hashes[i]
 251             .traverse_noresize <opt_pass *, statistics_fini_1>
 252             (passes->get_pass_for_id (i));
 253     }
 254
 255   dump_end (statistics_dump_nr, statistics_dump_file);
 256 }
 257
 258 /* Register the statistics dump file.  */
 259
 260 void
 261 statistics_early_init (void)
 262 {
 263   statistics_dump_nr = dump_register (".statistics", "statistics",
 264                                       "statistics", TDF_TREE, OPTGROUP_NONE);
 265 }
 266
 267 /* Init the statistics.  */
 268
 269 void
 270 statistics_init (void)
 271 {
 272   statistics_dump_file = dump_begin (statistics_dump_nr, NULL);
 273   statistics_dump_flags = get_dump_file_info (statistics_dump_nr)->pflags;
 274 }
 275
 276 /* Lookup or add a statistics counter in the hashtable HASH with ID, VAL
 277    and HISTOGRAM_P.  */
 278
 279 static statistics_counter_t *
 280 lookup_or_add_counter (stats_counter_table_type hash, const char *id, int val,
 281                        bool histogram_p)
 282 {
 283   statistics_counter_t **counter;
 284   statistics_counter_t c;
 285   c.id = id;
 286   c.val = val;
 287   counter = hash.find_slot (&c, INSERT);
 288   if (!*counter)
 289     {
 290       *counter = XNEW (struct statistics_counter_s);
 291       (*counter)->id = xstrdup (id);
 292       (*counter)->val = val;
 293       (*counter)->histogram_p = histogram_p;
 294       (*counter)->prev_dumped_count = 0;
 295       (*counter)->count = 0;
 296     }
 297   return *counter;
 298 }
 299
 300 /* Add statistics information about event ID in function FN.
 301    This will increment the counter associated with ID by INCR.
 302    It will also dump the event to the global statistics file if requested.  */
 303
 304 void
 305 statistics_counter_event (struct function *fn, const char *id, int incr)
 306 {
 307   statistics_counter_t *counter;
 308
 309   if ((!(dump_flags & TDF_STATS)
 310        && !statistics_dump_file)
 311       || incr == 0)
 312     return;
 313
 314   if (current_pass->static_pass_number != -1)
 315     {
 316       counter = lookup_or_add_counter (curr_statistics_hash (), id, 0, false);
 317       gcc_assert (!counter->histogram_p);
 318       counter->count += incr;
 319     }
 320
 321   if (!statistics_dump_file
 322       || !(statistics_dump_flags & TDF_DETAILS))
 323     return;
 324
 325   fprintf (statistics_dump_file,
 326            "%d %s \"%s\" \"%s\" %d\n",
 327            current_pass->static_pass_number,
 328            current_pass->name,
 329            id,
 330            function_name (fn),
 331            incr);
 332 }
 333
 334 /* Add statistics information about event ID in function FN with the
 335    histogram value VAL.
 336    It will dump the event to the global statistics file if requested.  */
 337
 338 void
 339 statistics_histogram_event (struct function *fn, const char *id, int val)
 340 {
 341   statistics_counter_t *counter;
 342
 343   if (!(dump_flags & TDF_STATS)
 344       && !statistics_dump_file)
 345     return;
 346
 347   counter = lookup_or_add_counter (curr_statistics_hash (), id, val, true);
 348   gcc_assert (counter->histogram_p);
 349   counter->count += 1;
 350
 351   if (!statistics_dump_file
 352       || !(statistics_dump_flags & TDF_DETAILS))
 353     return;
 354
 355   fprintf (statistics_dump_file,
 356            "%d %s \"%s == %d\" \"%s\" 1\n",
 357            current_pass->static_pass_number,
 358            current_pass->name,
 359            id, val,
 360            function_name (fn));
 361 }