1 /* Timing variables for measuring compiler performance.
2 Copyright (C) 2000, 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Alex Samuel <samuel@codesourcery.com>
5 This file is part of GCC.
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
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
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, 51 Franklin Street, Fifth Floor, Boston, MA
24 #ifdef HAVE_SYS_TIMES_H
25 # include <sys/times.h>
27 #ifdef HAVE_SYS_RESOURCE_H
28 #include <sys/resource.h>
30 #include "coretypes.h"
40 #ifndef HAVE_STRUCT_TMS
51 # define RUSAGE_SELF 0
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 */
60 # define TICKS_PER_SECOND CLK_TCK /* POSIX 1003.1-1988; obsolescent */
63 # define TICKS_PER_SECOND HZ /* traditional UNIX */
65 # define TICKS_PER_SECOND 100 /* often the correct value */
70 /* Prefer times to getrusage to clock (each gives successively less
73 # if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES
74 extern clock_t times (struct tms
*);
77 # define HAVE_USER_TIME
78 # define HAVE_SYS_TIME
79 # define HAVE_WALL_TIME
82 # if defined HAVE_DECL_GETRUSAGE && !HAVE_DECL_GETRUSAGE
83 extern int getrusage (int, struct rusage
*);
85 # define USE_GETRUSAGE
86 # define HAVE_USER_TIME
87 # define HAVE_SYS_TIME
90 # if defined HAVE_DECL_CLOCK && !HAVE_DECL_CLOCK
91 extern clock_t clock (void);
94 # define HAVE_USER_TIME
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? */
104 static double ticks_to_msec
;
105 #define TICKS_TO_MSEC (1 / (double)TICKS_PER_SECOND)
109 static double clocks_to_msec
;
110 #define CLOCKS_TO_MSEC (1 / (double)CLOCKS_PER_SEC)
118 /* Total amount of memory allocated by garbage collector. */
120 size_t timevar_ggc_mem_total
;
122 /* The amount of memory that will cause us to report the timevar even
123 if the time spent is not significant. */
125 #define GGC_MEM_BOUND (1 << 20)
127 /* See timevar.h for an explanation of timing variables. */
129 /* A timing variable. */
133 /* Elapsed time for this variable. */
134 struct timevar_time_def elapsed
;
136 /* If this variable is timed independently of the timing stack,
137 using timevar_start, this contains the start time. */
138 struct timevar_time_def start_time
;
140 /* The name of this timing variable. */
143 /* Nonzero if this timing variable is running as a standalone
145 unsigned standalone
: 1;
147 /* Nonzero if this timing variable was ever started or pushed onto
152 /* An element on the timing stack. Elapsed time is attributed to the
153 topmost timing variable on the stack. */
155 struct timevar_stack_def
157 /* The timing variable at this stack level. */
158 struct timevar_def
*timevar
;
160 /* The next lower timing variable context in the stack. */
161 struct timevar_stack_def
*next
;
164 /* Declared timing variables. Constructed from the contents of
166 static struct timevar_def timevars
[TIMEVAR_LAST
];
168 /* The top of the timing stack. */
169 static struct timevar_stack_def
*stack
;
171 /* A list of unused (i.e. allocated and subsequently popped)
172 timevar_stack_def instances. */
173 static struct timevar_stack_def
*unused_stack_instances
;
175 /* The time at which the topmost element on the timing stack was
176 pushed. Time elapsed since then is attributed to the topmost
178 static struct timevar_time_def start_time
;
180 static void get_time (struct timevar_time_def
*);
181 static void timevar_accumulate (struct timevar_time_def
*,
182 struct timevar_time_def
*,
183 struct timevar_time_def
*);
185 /* Fill the current times into TIME. The definition of this function
186 also defines any or all of the HAVE_USER_TIME, HAVE_SYS_TIME, and
187 HAVE_WALL_TIME macros. */
190 get_time (struct timevar_time_def
*now
)
195 now
->ggc_mem
= timevar_ggc_mem_total
;
203 now
->wall
= times (&tms
) * ticks_to_msec
;
204 now
->user
= tms
.tms_utime
* ticks_to_msec
;
205 now
->sys
= tms
.tms_stime
* ticks_to_msec
;
208 struct rusage rusage
;
209 getrusage (RUSAGE_SELF
, &rusage
);
210 now
->user
= rusage
.ru_utime
.tv_sec
+ rusage
.ru_utime
.tv_usec
* 1e-6;
211 now
->sys
= rusage
.ru_stime
.tv_sec
+ rusage
.ru_stime
.tv_usec
* 1e-6;
214 now
->user
= clock () * clocks_to_msec
;
219 /* Add the difference between STOP_TIME and START_TIME to TIMER. */
222 timevar_accumulate (struct timevar_time_def
*timer
,
223 struct timevar_time_def
*start_time
,
224 struct timevar_time_def
*stop_time
)
226 timer
->user
+= stop_time
->user
- start_time
->user
;
227 timer
->sys
+= stop_time
->sys
- start_time
->sys
;
228 timer
->wall
+= stop_time
->wall
- start_time
->wall
;
229 timer
->ggc_mem
+= stop_time
->ggc_mem
- start_time
->ggc_mem
;
232 /* Initialize timing variables. */
237 timevar_enable
= true;
239 /* Zero all elapsed times. */
240 memset (timevars
, 0, sizeof (timevars
));
242 /* Initialize the names of timing variables. */
243 #define DEFTIMEVAR(identifier__, name__) \
244 timevars[identifier__].name = name__;
245 #include "timevar.def"
249 ticks_to_msec
= TICKS_TO_MSEC
;
252 clocks_to_msec
= CLOCKS_TO_MSEC
;
256 /* Push TIMEVAR onto the timing stack. No further elapsed time is
257 attributed to the previous topmost timing variable on the stack;
258 subsequent elapsed time is attributed to TIMEVAR, until it is
259 popped or another element is pushed on top.
261 TIMEVAR cannot be running as a standalone timer. */
264 timevar_push_1 (timevar_id_t timevar
)
266 struct timevar_def
*tv
= &timevars
[timevar
];
267 struct timevar_stack_def
*context
;
268 struct timevar_time_def now
;
270 /* Mark this timing variable as used. */
273 /* Can't push a standalone timer. */
274 gcc_assert (!tv
->standalone
);
276 /* What time is it? */
279 /* If the stack isn't empty, attribute the current elapsed time to
280 the old topmost element. */
282 timevar_accumulate (&stack
->timevar
->elapsed
, &start_time
, &now
);
284 /* Reset the start time; from now on, time is attributed to
288 /* See if we have a previously-allocated stack instance. If so,
289 take it off the list. If not, malloc a new one. */
290 if (unused_stack_instances
!= NULL
)
292 context
= unused_stack_instances
;
293 unused_stack_instances
= unused_stack_instances
->next
;
296 context
= XNEW (struct timevar_stack_def
);
298 /* Fill it in and put it on the stack. */
299 context
->timevar
= tv
;
300 context
->next
= stack
;
304 /* Pop the topmost timing variable element off the timing stack. The
305 popped variable must be TIMEVAR. Elapsed time since the that
306 element was pushed on, or since it was last exposed on top of the
307 stack when the element above it was popped off, is credited to that
311 timevar_pop_1 (timevar_id_t timevar
)
313 struct timevar_time_def now
;
314 struct timevar_stack_def
*popped
= stack
;
316 gcc_assert (&timevars
[timevar
] == stack
->timevar
);
318 /* What time is it? */
321 /* Attribute the elapsed time to the element we're popping. */
322 timevar_accumulate (&popped
->timevar
->elapsed
, &start_time
, &now
);
324 /* Reset the start time; from now on, time is attributed to the
325 element just exposed on the stack. */
328 /* Take the item off the stack. */
331 /* Don't delete the stack element; instead, add it to the list of
332 unused elements for later use. */
333 popped
->next
= unused_stack_instances
;
334 unused_stack_instances
= popped
;
337 /* Start timing TIMEVAR independently of the timing stack. Elapsed
338 time until timevar_stop is called for the same timing variable is
339 attributed to TIMEVAR. */
342 timevar_start (timevar_id_t timevar
)
344 struct timevar_def
*tv
= &timevars
[timevar
];
349 /* Mark this timing variable as used. */
352 /* Don't allow the same timing variable to be started more than
354 gcc_assert (!tv
->standalone
);
357 get_time (&tv
->start_time
);
360 /* Stop timing TIMEVAR. Time elapsed since timevar_start was called
361 is attributed to it. */
364 timevar_stop (timevar_id_t timevar
)
366 struct timevar_def
*tv
= &timevars
[timevar
];
367 struct timevar_time_def now
;
372 /* TIMEVAR must have been started via timevar_start. */
373 gcc_assert (tv
->standalone
);
376 timevar_accumulate (&tv
->elapsed
, &tv
->start_time
, &now
);
379 /* Summarize timing variables to FP. The timing variable TV_TOTAL has
380 a special meaning -- it's considered to be the total elapsed time,
381 for normalizing the others, and is displayed last. */
384 timevar_print (FILE *fp
)
386 /* Only print stuff if we have some sort of time information. */
387 #if defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME) || defined (HAVE_WALL_TIME)
388 unsigned int /* timevar_id_t */ id
;
389 struct timevar_time_def
*total
= &timevars
[TV_TOTAL
].elapsed
;
390 struct timevar_time_def now
;
395 /* Update timing information in case we're calling this from GDB. */
400 /* What time is it? */
403 /* If the stack isn't empty, attribute the current elapsed time to
404 the old topmost element. */
406 timevar_accumulate (&stack
->timevar
->elapsed
, &start_time
, &now
);
408 /* Reset the start time; from now on, time is attributed to
412 fputs (_("\nExecution times (seconds)\n"), fp
);
413 for (id
= 0; id
< (unsigned int) TIMEVAR_LAST
; ++id
)
415 struct timevar_def
*tv
= &timevars
[(timevar_id_t
) id
];
416 const double tiny
= 5e-3;
418 /* Don't print the total execution time here; that goes at the
420 if ((timevar_id_t
) id
== TV_TOTAL
)
423 /* Don't print timing variables that were never used. */
427 /* Don't print timing variables if we're going to get a row of
429 if (tv
->elapsed
.user
< tiny
430 && tv
->elapsed
.sys
< tiny
431 && tv
->elapsed
.wall
< tiny
432 && tv
->elapsed
.ggc_mem
< GGC_MEM_BOUND
)
435 /* The timing variable name. */
436 fprintf (fp
, " %-22s:", tv
->name
);
438 #ifdef HAVE_USER_TIME
439 /* Print user-mode time for this process. */
440 fprintf (fp
, "%7.2f (%2.0f%%) usr",
442 (total
->user
== 0 ? 0 : tv
->elapsed
.user
/ total
->user
) * 100);
443 #endif /* HAVE_USER_TIME */
446 /* Print system-mode time for this process. */
447 fprintf (fp
, "%7.2f (%2.0f%%) sys",
449 (total
->sys
== 0 ? 0 : tv
->elapsed
.sys
/ total
->sys
) * 100);
450 #endif /* HAVE_SYS_TIME */
452 #ifdef HAVE_WALL_TIME
453 /* Print wall clock time elapsed. */
454 fprintf (fp
, "%7.2f (%2.0f%%) wall",
456 (total
->wall
== 0 ? 0 : tv
->elapsed
.wall
/ total
->wall
) * 100);
457 #endif /* HAVE_WALL_TIME */
459 /* Print the amount of ggc memory allocated. */
460 fprintf (fp
, "%8u kB (%2.0f%%) ggc",
461 (unsigned) (tv
->elapsed
.ggc_mem
>> 10),
464 : (float) tv
->elapsed
.ggc_mem
/ total
->ggc_mem
) * 100);
469 /* Print total time. */
470 fputs (_(" TOTAL :"), fp
);
471 #ifdef HAVE_USER_TIME
472 fprintf (fp
, "%7.2f ", total
->user
);
475 fprintf (fp
, "%7.2f ", total
->sys
);
477 #ifdef HAVE_WALL_TIME
478 fprintf (fp
, "%7.2f ", total
->wall
);
480 fprintf (fp
, "%8u kB\n", (unsigned) (total
->ggc_mem
>> 10));
482 #ifdef ENABLE_CHECKING
483 fprintf (fp
, "Extra diagnostic checks enabled; compiler may run slowly.\n");
484 fprintf (fp
, "Configure with --enable-checking=release to disable checks.\n");
486 #ifndef ASSERT_CHECKING
487 fprintf (fp
, "Assert checking was disable; if you do an official compiling\n");
488 fprintf (fp
, "time testing please use --enable-checking=release instead of\n");
489 fprintf (fp
, "--disable-checking.\n");
492 #endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
493 || defined (HAVE_WALL_TIME) */
496 /* Prints a message to stderr stating that time elapsed in STR is
497 TOTAL (given in microseconds). */
500 print_time (const char *str
, long total
)
502 long all_time
= get_run_time ();
504 _("time in %s: %ld.%06ld (%ld%%)\n"),
505 str
, total
/ 1000000, total
% 1000000,
507 : (long) (((100.0 * (double) total
) / (double) all_time
) + .5));