OSDN Git Service

* targhooks.c (default_unwind_emit, default_scalar_mode_supported_p):
[pf3gnuchains/gcc-fork.git] / gcc / timevar.c
1 /* Timing variables for measuring compiler performance.
2    Copyright (C) 2000, 2003, 2004 Free Software Foundation, Inc.
3    Contributed by Alex Samuel <samuel@codesourcery.com>
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 2, 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 COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #ifdef HAVE_SYS_TIMES_H
25 # include <sys/times.h>
26 #endif
27 #ifdef HAVE_SYS_RESOURCE_H
28 #include <sys/resource.h>
29 #endif
30 #include "coretypes.h"
31 #include "tm.h"
32 #include "intl.h"
33 #include "rtl.h"
34 #include "toplev.h"
35
36 #ifndef HAVE_CLOCK_T
37 typedef int clock_t;
38 #endif
39
40 #ifndef HAVE_STRUCT_TMS
41 struct tms
42 {
43   clock_t tms_utime;
44   clock_t tms_stime;
45   clock_t tms_cutime;
46   clock_t tms_cstime;
47 };
48 #endif
49
50 #ifndef RUSAGE_SELF
51 # define RUSAGE_SELF 0
52 #endif
53
54 /* Calculation of scale factor to convert ticks to microseconds.
55    We mustn't use CLOCKS_PER_SEC except with clock().  */
56 #if HAVE_SYSCONF && defined _SC_CLK_TCK
57 # define TICKS_PER_SECOND sysconf (_SC_CLK_TCK) /* POSIX 1003.1-1996 */
58 #else
59 # ifdef CLK_TCK
60 #  define TICKS_PER_SECOND CLK_TCK /* POSIX 1003.1-1988; obsolescent */
61 # else
62 #  ifdef HZ
63 #   define TICKS_PER_SECOND HZ  /* traditional UNIX */
64 #  else
65 #   define TICKS_PER_SECOND 100 /* often the correct value */
66 #  endif
67 # endif
68 #endif
69
70 /* Prefer times to getrusage to clock (each gives successively less
71    information).  */
72 #ifdef HAVE_TIMES
73 # if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES
74   extern clock_t times (struct tms *);
75 # endif
76 # define USE_TIMES
77 # define HAVE_USER_TIME
78 # define HAVE_SYS_TIME
79 # define HAVE_WALL_TIME
80 #else
81 #ifdef HAVE_GETRUSAGE
82 # if defined HAVE_DECL_GETRUSAGE && !HAVE_DECL_GETRUSAGE
83   extern int getrusage (int, struct rusage *);
84 # endif
85 # define USE_GETRUSAGE
86 # define HAVE_USER_TIME
87 # define HAVE_SYS_TIME
88 #else
89 #ifdef HAVE_CLOCK
90 # if defined HAVE_DECL_CLOCK && !HAVE_DECL_CLOCK
91   extern clock_t clock (void);
92 # endif
93 # define USE_CLOCK
94 # define HAVE_USER_TIME
95 #endif
96 #endif
97 #endif
98
99 /* libc is very likely to have snuck a call to sysconf() into one of
100    the underlying constants, and that can be very slow, so we have to
101    precompute them.  Whose wonderful idea was it to make all those
102    _constants_ variable at run time, anyway?  */
103 #ifdef USE_TIMES
104 static double ticks_to_msec;
105 #define TICKS_TO_MSEC (1 / (double)TICKS_PER_SECOND)
106 #endif
107
108 #ifdef USE_CLOCK
109 static double clocks_to_msec;
110 #define CLOCKS_TO_MSEC (1 / (double)CLOCKS_PER_SEC)
111 #endif
112
113 #include "flags.h"
114 #include "timevar.h"
115
116 static bool timevar_enable;
117
118 /* See timevar.h for an explanation of timing variables.  */
119
120 /* A timing variable.  */
121
122 struct timevar_def
123 {
124   /* Elapsed time for this variable.  */
125   struct timevar_time_def elapsed;
126
127   /* If this variable is timed independently of the timing stack,
128      using timevar_start, this contains the start time.  */
129   struct timevar_time_def start_time;
130
131   /* The name of this timing variable.  */
132   const char *name;
133
134   /* Nonzero if this timing variable is running as a standalone
135      timer.  */
136   unsigned standalone : 1;
137
138   /* Nonzero if this timing variable was ever started or pushed onto
139      the timing stack.  */
140   unsigned used : 1;
141 };
142
143 /* An element on the timing stack.  Elapsed time is attributed to the
144    topmost timing variable on the stack.  */
145
146 struct timevar_stack_def
147 {
148   /* The timing variable at this stack level.  */
149   struct timevar_def *timevar;
150
151   /* The next lower timing variable context in the stack.  */
152   struct timevar_stack_def *next;
153 };
154
155 /* Declared timing variables.  Constructed from the contents of
156    timevar.def.  */
157 static struct timevar_def timevars[TIMEVAR_LAST];
158
159 /* The top of the timing stack.  */
160 static struct timevar_stack_def *stack;
161
162 /* A list of unused (i.e. allocated and subsequently popped)
163    timevar_stack_def instances.  */
164 static struct timevar_stack_def *unused_stack_instances;
165
166 /* The time at which the topmost element on the timing stack was
167    pushed.  Time elapsed since then is attributed to the topmost
168    element.  */
169 static struct timevar_time_def start_time;
170
171 static void get_time (struct timevar_time_def *);
172 static void timevar_accumulate (struct timevar_time_def *,
173                                 struct timevar_time_def *,
174                                 struct timevar_time_def *);
175
176 /* Fill the current times into TIME.  The definition of this function
177    also defines any or all of the HAVE_USER_TIME, HAVE_SYS_TIME, and
178    HAVE_WALL_TIME macros.  */
179
180 static void
181 get_time (struct timevar_time_def *now)
182 {
183   now->user = 0;
184   now->sys  = 0;
185   now->wall = 0;
186
187   if (!timevar_enable)
188     return;
189
190   {
191 #ifdef USE_TIMES
192     struct tms tms;
193     now->wall = times (&tms)  * ticks_to_msec;
194     now->user = tms.tms_utime * ticks_to_msec;
195     now->sys  = tms.tms_stime * ticks_to_msec;
196 #endif
197 #ifdef USE_GETRUSAGE
198     struct rusage rusage;
199     getrusage (RUSAGE_SELF, &rusage);
200     now->user = rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec * 1e-6;
201     now->sys  = rusage.ru_stime.tv_sec + rusage.ru_stime.tv_usec * 1e-6;
202 #endif
203 #ifdef USE_CLOCK
204     now->user = clock () * clocks_to_msec;
205 #endif
206   }
207 }
208
209 /* Add the difference between STOP_TIME and START_TIME to TIMER.  */
210
211 static void
212 timevar_accumulate (struct timevar_time_def *timer,
213                     struct timevar_time_def *start_time,
214                     struct timevar_time_def *stop_time)
215 {
216   timer->user += stop_time->user - start_time->user;
217   timer->sys += stop_time->sys - start_time->sys;
218   timer->wall += stop_time->wall - start_time->wall;
219 }
220
221 /* Initialize timing variables.  */
222
223 void
224 timevar_init (void)
225 {
226   timevar_enable = true;
227
228   /* Zero all elapsed times.  */
229   memset (timevars, 0, sizeof (timevars));
230
231   /* Initialize the names of timing variables.  */
232 #define DEFTIMEVAR(identifier__, name__) \
233   timevars[identifier__].name = name__;
234 #include "timevar.def"
235 #undef DEFTIMEVAR
236
237 #ifdef USE_TIMES
238   ticks_to_msec = TICKS_TO_MSEC;
239 #endif
240 #ifdef USE_CLOCK
241   clocks_to_msec = CLOCKS_TO_MSEC;
242 #endif
243 }
244
245 /* Push TIMEVAR onto the timing stack.  No further elapsed time is
246    attributed to the previous topmost timing variable on the stack;
247    subsequent elapsed time is attributed to TIMEVAR, until it is
248    popped or another element is pushed on top.
249
250    TIMEVAR cannot be running as a standalone timer.  */
251
252 void
253 timevar_push (timevar_id_t timevar)
254 {
255   struct timevar_def *tv = &timevars[timevar];
256   struct timevar_stack_def *context;
257   struct timevar_time_def now;
258
259   if (!timevar_enable)
260     return;
261
262   /* Mark this timing variable as used.  */
263   tv->used = 1;
264
265   /* Can't push a standalone timer.  */
266   gcc_assert (!tv->standalone);
267
268   /* What time is it?  */
269   get_time (&now);
270
271   /* If the stack isn't empty, attribute the current elapsed time to
272      the old topmost element.  */
273   if (stack)
274     timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
275
276   /* Reset the start time; from now on, time is attributed to
277      TIMEVAR.  */
278   start_time = now;
279
280   /* See if we have a previously-allocated stack instance.  If so,
281      take it off the list.  If not, malloc a new one.  */
282   if (unused_stack_instances != NULL)
283     {
284       context = unused_stack_instances;
285       unused_stack_instances = unused_stack_instances->next;
286     }
287   else
288     context = xmalloc (sizeof (struct timevar_stack_def));
289
290   /* Fill it in and put it on the stack.  */
291   context->timevar = tv;
292   context->next = stack;
293   stack = context;
294 }
295
296 /* Pop the topmost timing variable element off the timing stack.  The
297    popped variable must be TIMEVAR.  Elapsed time since the that
298    element was pushed on, or since it was last exposed on top of the
299    stack when the element above it was popped off, is credited to that
300    timing variable.  */
301
302 void
303 timevar_pop (timevar_id_t timevar)
304 {
305   struct timevar_time_def now;
306   struct timevar_stack_def *popped = stack;
307
308   if (!timevar_enable)
309     return;
310
311   gcc_assert (&timevars[timevar] == stack->timevar);
312   
313   /* What time is it?  */
314   get_time (&now);
315
316   /* Attribute the elapsed time to the element we're popping.  */
317   timevar_accumulate (&popped->timevar->elapsed, &start_time, &now);
318
319   /* Reset the start time; from now on, time is attributed to the
320      element just exposed on the stack.  */
321   start_time = now;
322
323   /* Take the item off the stack.  */
324   stack = stack->next;
325
326   /* Don't delete the stack element; instead, add it to the list of
327      unused elements for later use.  */
328   popped->next = unused_stack_instances;
329   unused_stack_instances = popped;
330 }
331
332 /* Start timing TIMEVAR independently of the timing stack.  Elapsed
333    time until timevar_stop is called for the same timing variable is
334    attributed to TIMEVAR.  */
335
336 void
337 timevar_start (timevar_id_t timevar)
338 {
339   struct timevar_def *tv = &timevars[timevar];
340
341   if (!timevar_enable)
342     return;
343
344   /* Mark this timing variable as used.  */
345   tv->used = 1;
346
347   /* Don't allow the same timing variable to be started more than
348      once.  */
349   gcc_assert (!tv->standalone);
350   tv->standalone = 1;
351
352   get_time (&tv->start_time);
353 }
354
355 /* Stop timing TIMEVAR.  Time elapsed since timevar_start was called
356    is attributed to it.  */
357
358 void
359 timevar_stop (timevar_id_t timevar)
360 {
361   struct timevar_def *tv = &timevars[timevar];
362   struct timevar_time_def now;
363
364   if (!timevar_enable)
365     return;
366
367   /* TIMEVAR must have been started via timevar_start.  */
368   gcc_assert (tv->standalone);
369
370   get_time (&now);
371   timevar_accumulate (&tv->elapsed, &tv->start_time, &now);
372 }
373
374 /* Fill the elapsed time for TIMEVAR into ELAPSED.  Returns
375    update-to-date information even if TIMEVAR is currently running.  */
376
377 void
378 timevar_get (timevar_id_t timevar, struct timevar_time_def *elapsed)
379 {
380   struct timevar_def *tv = &timevars[timevar];
381   struct timevar_time_def now;
382
383   *elapsed = tv->elapsed;
384
385   /* Is TIMEVAR currently running as a standalone timer?  */
386   if (tv->standalone)
387     {
388       get_time (&now);
389       timevar_accumulate (elapsed, &tv->start_time, &now);
390     }
391   /* Or is TIMEVAR at the top of the timer stack?  */
392   else if (stack->timevar == tv)
393     {
394       get_time (&now);
395       timevar_accumulate (elapsed, &start_time, &now);
396     }
397 }
398
399 /* Summarize timing variables to FP.  The timing variable TV_TOTAL has
400    a special meaning -- it's considered to be the total elapsed time,
401    for normalizing the others, and is displayed last.  */
402
403 void
404 timevar_print (FILE *fp)
405 {
406   /* Only print stuff if we have some sort of time information.  */
407 #if defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME) || defined (HAVE_WALL_TIME)
408   unsigned int /* timevar_id_t */ id;
409   struct timevar_time_def *total = &timevars[TV_TOTAL].elapsed;
410   struct timevar_time_def now;
411
412   if (!timevar_enable)
413     return;
414
415   /* Update timing information in case we're calling this from GDB.  */
416
417   if (fp == 0)
418     fp = stderr;
419
420   /* What time is it?  */
421   get_time (&now);
422
423   /* If the stack isn't empty, attribute the current elapsed time to
424      the old topmost element.  */
425   if (stack)
426     timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
427
428   /* Reset the start time; from now on, time is attributed to
429      TIMEVAR.  */
430   start_time = now;
431
432   fputs (_("\nExecution times (seconds)\n"), fp);
433   for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id)
434     {
435       struct timevar_def *tv = &timevars[(timevar_id_t) id];
436       const double tiny = 5e-3;
437
438       /* Don't print the total execution time here; that goes at the
439          end.  */
440       if ((timevar_id_t) id == TV_TOTAL)
441         continue;
442
443       /* Don't print timing variables that were never used.  */
444       if (!tv->used)
445         continue;
446
447       /* Don't print timing variables if we're going to get a row of
448          zeroes.  */
449       if (tv->elapsed.user < tiny
450           && tv->elapsed.sys < tiny
451           && tv->elapsed.wall < tiny)
452         continue;
453
454       /* The timing variable name.  */
455       fprintf (fp, " %-22s:", tv->name);
456
457 #ifdef HAVE_USER_TIME
458       /* Print user-mode time for this process.  */
459       fprintf (fp, "%7.2f (%2.0f%%) usr",
460                tv->elapsed.user,
461                (total->user == 0 ? 0 : tv->elapsed.user / total->user) * 100);
462 #endif /* HAVE_USER_TIME */
463
464 #ifdef HAVE_SYS_TIME
465       /* Print system-mode time for this process.  */
466       fprintf (fp, "%7.2f (%2.0f%%) sys",
467                tv->elapsed.sys,
468                (total->sys == 0 ? 0 : tv->elapsed.sys / total->sys) * 100);
469 #endif /* HAVE_SYS_TIME */
470
471 #ifdef HAVE_WALL_TIME
472       /* Print wall clock time elapsed.  */
473       fprintf (fp, "%7.2f (%2.0f%%) wall",
474                tv->elapsed.wall,
475                (total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100);
476 #endif /* HAVE_WALL_TIME */
477
478       putc ('\n', fp);
479     }
480
481   /* Print total time.  */
482   fputs (_(" TOTAL                 :"), fp);
483 #ifdef HAVE_USER_TIME
484   fprintf (fp, "%7.2f          ", total->user);
485 #endif
486 #ifdef HAVE_SYS_TIME
487   fprintf (fp, "%7.2f          ", total->sys);
488 #endif
489 #ifdef HAVE_WALL_TIME
490   fprintf (fp, "%7.2f\n", total->wall);
491 #endif
492
493 #ifdef ENABLE_CHECKING
494   fprintf (fp, "Extra diagnostic checks enabled; compiler may run slowly.\n");
495   fprintf (fp, "Configure with --disable-checking to disable checks.\n");
496 #endif
497
498 #endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
499           || defined (HAVE_WALL_TIME) */
500 }
501
502 /* Prints a message to stderr stating that time elapsed in STR is
503    TOTAL (given in microseconds).  */
504
505 void
506 print_time (const char *str, long total)
507 {
508   long all_time = get_run_time ();
509   fprintf (stderr,
510            _("time in %s: %ld.%06ld (%ld%%)\n"),
511            str, total / 1000000, total % 1000000,
512            all_time == 0 ? 0
513            : (long) (((100.0 * (double) total) / (double) all_time) + .5));
514 }