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