1 /* Timing variables for measuring compiler performance.
2 Copyright (C) 2000 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, 59 Temple Place - Suite 330, Boston, MA
27 #ifdef HAVE_SYS_TIMES_H
28 # include <sys/times.h>
30 #ifdef HAVE_SYS_RESOURCE_H
31 #include <sys/resource.h>
38 #ifndef HAVE_STRUCT_TMS
48 #if defined HAVE_DECL_GETRUSAGE && !HAVE_DECL_GETRUSAGE
49 extern int getrusage PARAMS ((int, struct rusage *));
51 #if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES
52 extern clock_t times PARAMS ((struct tms *));
54 #if defined HAVE_DECL_CLOCK && !HAVE_DECL_CLOCK
55 extern clock_t clock PARAMS ((void));
59 # define RUSAGE_SELF 0
62 /* Calculation of scale factor to convert ticks to microseconds.
63 We mustn't use CLOCKS_PER_SEC except with clock(). */
64 #if HAVE_SYSCONF && defined _SC_CLK_TCK
65 # define TICKS_PER_SECOND sysconf (_SC_CLK_TCK) /* POSIX 1003.1-1996 */
68 # define TICKS_PER_SECOND CLK_TCK /* POSIX 1003.1-1988; obsolescent */
71 # define TICKS_PER_SECOND HZ /* traditional UNIX */
73 # define TICKS_PER_SECOND 100 /* often the correct value */
78 /* Prefer times to getrusage to clock (each gives successively less
82 # define HAVE_USER_TIME
83 # define HAVE_SYS_TIME
84 # define HAVE_WALL_TIME
87 # define USE_GETRUSAGE
88 # define HAVE_USER_TIME
89 # define HAVE_SYS_TIME
93 # define HAVE_USER_TIME
98 /* libc is very likely to have snuck a call to sysconf() into one of
99 the underlying constants, and that can be very slow, so we have to
100 precompute them. Whose wonderful idea was it to make all those
101 _constants_ variable at run time, anyway? */
103 static float ticks_to_msec;
104 #define TICKS_TO_MSEC (1 / (float)TICKS_PER_SECOND)
108 static float clocks_to_msec;
109 #define CLOCKS_TO_MSEC (1 / (float)CLOCKS_PER_SEC)
116 /* See timevar.h for an explanation of timing variables. */
118 /* This macro evaluates to nonzero if timing variables are enabled. */
119 #define TIMEVAR_ENABLE (time_report)
121 /* A timing variable. */
125 /* Elapsed time for this variable. */
126 struct timevar_time_def elapsed;
128 /* If this variable is timed independently of the timing stack,
129 using timevar_start, this contains the start time. */
130 struct timevar_time_def start_time;
132 /* The name of this timing variable. */
135 /* Non-zero if this timing variable is running as a standalone
137 unsigned standalone : 1;
139 /* Non-zero if this timing variable was ever started or pushed onto
144 /* An element on the timing stack. Elapsed time is attributed to the
145 topmost timing variable on the stack. */
147 struct timevar_stack_def
149 /* The timing variable at this stack level. */
150 struct timevar_def *timevar;
152 /* The next lower timing variable context in the stack. */
153 struct timevar_stack_def *next;
156 /* Declared timing variables. Constructed from the contents of
158 static struct timevar_def timevars[TIMEVAR_LAST];
160 /* The top of the timing stack. */
161 static struct timevar_stack_def *stack;
163 /* A list of unused (i.e. allocated and subsequently popped)
164 timevar_stack_def instances. */
165 static struct timevar_stack_def *unused_stack_instances;
167 /* The time at which the topmost element on the timing stack was
168 pushed. Time elapsed since then is attributed to the topmost
170 static struct timevar_time_def start_time;
173 PARAMS ((struct timevar_time_def *));
174 static void timevar_accumulate
175 PARAMS ((struct timevar_time_def *, struct timevar_time_def *,
176 struct timevar_time_def *));
178 /* Fill the current times into TIME. The definition of this function
179 also defines any or all of the HAVE_USER_TIME, HAVE_SYS_TIME, and
180 HAVE_WALL_TIME macros. */
184 struct timevar_time_def *now;
196 now->wall = times (&tms) * ticks_to_msec;
197 now->user = tms.tms_utime * ticks_to_msec;
198 now->sys = tms.tms_stime * ticks_to_msec;
201 struct rusage rusage;
202 getrusage (RUSAGE_SELF, &rusage);
203 now->user = rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec * 1e-6;
204 now->sys = rusage.ru_stime.tv_sec + rusage.ru_stime.tv_usec * 1e-6;
207 now->user = clock () * clocks_to_msec;
212 /* Add the difference between STOP_TIME and START_TIME to TIMER. */
215 timevar_accumulate (timer, start_time, stop_time)
216 struct timevar_time_def *timer;
217 struct timevar_time_def *start_time;
218 struct timevar_time_def *stop_time;
220 timer->user += stop_time->user - start_time->user;
221 timer->sys += stop_time->sys - start_time->sys;
222 timer->wall += stop_time->wall - start_time->wall;
225 /* Initialize timing variables. */
233 /* Zero all elapsed times. */
234 memset ((void *) timevars, 0, sizeof (timevars));
236 /* Initialize the names of timing variables. */
237 #define DEFTIMEVAR(identifier__, name__) \
238 timevars[identifier__].name = name__;
239 #include "timevar.def"
243 ticks_to_msec = TICKS_TO_MSEC;
246 clocks_to_msec = CLOCKS_TO_MSEC;
250 /* Push TIMEVAR onto the timing stack. No further elapsed time is
251 attributed to the previous topmost timing variable on the stack;
252 subsequent elapsed time is attributed to TIMEVAR, until it is
253 popped or another element is pushed on top.
255 TIMEVAR cannot be running as a standalone timer. */
258 timevar_push (timevar)
259 timevar_id_t timevar;
261 struct timevar_def *tv = &timevars[timevar];
262 struct timevar_stack_def *context;
263 struct timevar_time_def now;
268 /* Mark this timing variable as used. */
271 /* Can't push a standalone timer. */
275 /* What time is it? */
278 /* If the stack isn't empty, attribute the current elapsed time to
279 the old topmost element. */
281 timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
283 /* Reset the start time; from now on, time is attributed to
287 /* See if we have a previously-allocated stack instance. If so,
288 take it off the list. If not, malloc a new one. */
289 if (unused_stack_instances != NULL)
291 context = unused_stack_instances;
292 unused_stack_instances = unused_stack_instances->next;
295 context = (struct timevar_stack_def *)
296 xmalloc (sizeof (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 (timevar)
312 timevar_id_t timevar;
314 struct timevar_time_def now;
315 struct timevar_stack_def *popped = stack;
320 if (&timevars[timevar] != stack->timevar)
322 sorry ("cannot timevar_pop '%s' when top of timevars stack is '%s'",
323 timevars[timevar].name, stack->timevar->name);
327 /* What time is it? */
330 /* Attribute the elapsed time to the element we're popping. */
331 timevar_accumulate (&popped->timevar->elapsed, &start_time, &now);
333 /* Reset the start time; from now on, time is attributed to the
334 element just exposed on the stack. */
337 /* Take the item off the stack. */
340 /* Don't delete the stack element; instead, add it to the list of
341 unused elements for later use. */
342 popped->next = unused_stack_instances;
343 unused_stack_instances = popped;
346 /* Start timing TIMEVAR independently of the timing stack. Elapsed
347 time until timevar_stop is called for the same timing variable is
348 attributed to TIMEVAR. */
351 timevar_start (timevar)
352 timevar_id_t timevar;
354 struct timevar_def *tv = &timevars[timevar];
359 /* Mark this timing variable as used. */
362 /* Don't allow the same timing variable to be started more than
368 get_time (&tv->start_time);
371 /* Stop timing TIMEVAR. Time elapsed since timevar_start was called
372 is attributed to it. */
375 timevar_stop (timevar)
376 timevar_id_t timevar;
378 struct timevar_def *tv = &timevars[timevar];
379 struct timevar_time_def now;
384 /* TIMEVAR must have been started via timevar_start. */
389 timevar_accumulate (&tv->elapsed, &tv->start_time, &now);
392 /* Fill the elapsed time for TIMEVAR into ELAPSED. Returns
393 update-to-date information even if TIMEVAR is currently running. */
396 timevar_get (timevar, elapsed)
397 timevar_id_t timevar;
398 struct timevar_time_def *elapsed;
400 struct timevar_def *tv = &timevars[timevar];
401 struct timevar_time_def now;
403 *elapsed = tv->elapsed;
405 /* Is TIMEVAR currently running as a standalone timer? */
409 timevar_accumulate (elapsed, &tv->start_time, &now);
411 /* Or is TIMEVAR at the top of the timer stack? */
412 else if (stack->timevar == tv)
415 timevar_accumulate (elapsed, &start_time, &now);
419 /* Summarize timing variables to FP. The timing variable TV_TOTAL has
420 a special meaning -- it's considered to be the total elapsed time,
421 for normalizing the others, and is displayed last. */
427 /* Only print stuff if we have some sort of time information. */
428 #if defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME) || defined (HAVE_WALL_TIME)
429 unsigned int /* timevar_id_t */ id;
430 struct timevar_time_def *total = &timevars[TV_TOTAL].elapsed;
431 struct timevar_time_def now;
436 /* Update timing information in case we're calling this from GDB. */
441 /* What time is it? */
444 /* If the stack isn't empty, attribute the current elapsed time to
445 the old topmost element. */
447 timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
449 /* Reset the start time; from now on, time is attributed to
453 fputs (_("\nExecution times (seconds)\n"), fp);
454 for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id)
456 struct timevar_def *tv = &timevars[(timevar_id_t) id];
457 const float tiny = 5e-3;
459 /* Don't print the total execution time here; that goes at the
461 if ((timevar_id_t) id == TV_TOTAL)
464 /* Don't print timing variables that were never used. */
468 /* Don't print timing variables if we're going to get a row of
470 if (tv->elapsed.user < tiny
471 && tv->elapsed.sys < tiny
472 && tv->elapsed.wall < tiny)
475 /* The timing variable name. */
476 fprintf (fp, " %-22s:", tv->name);
478 #ifdef HAVE_USER_TIME
479 /* Print user-mode time for this process. */
480 fprintf (fp, "%7.2f (%2.0f%%) usr",
482 (total->user == 0 ? 0 : tv->elapsed.user / total->user) * 100);
483 #endif /* HAVE_USER_TIME */
486 /* Print system-mode time for this process. */
487 fprintf (fp, "%7.2f (%2.0f%%) sys",
489 (total->sys == 0 ? 0 : tv->elapsed.sys / total->sys) * 100);
490 #endif /* HAVE_SYS_TIME */
492 #ifdef HAVE_WALL_TIME
493 /* Print wall clock time elapsed. */
494 fprintf (fp, "%7.2f (%2.0f%%) wall",
496 (total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100);
497 #endif /* HAVE_WALL_TIME */
502 /* Print total time. */
503 fputs (_(" TOTAL :"), fp);
504 #ifdef HAVE_USER_TIME
505 fprintf (fp, "%7.2f ", total->user);
508 fprintf (fp, "%7.2f ", total->sys);
510 #ifdef HAVE_WALL_TIME
511 fprintf (fp, "%7.2f\n", total->wall);
514 #endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
515 || defined (HAVE_WALL_TIME) */
518 /* Returns time (user + system) used so far by the compiler process,
524 struct timevar_time_def total_elapsed;
525 timevar_get (TV_TOTAL, &total_elapsed);
526 return total_elapsed.user + total_elapsed.sys;
529 /* Prints a message to stderr stating that time elapsed in STR is
530 TOTAL (given in microseconds). */
533 print_time (str, total)
537 long all_time = get_run_time ();
539 _("time in %s: %ld.%06ld (%ld%%)\n"),
540 str, total / 1000000, total % 1000000,
542 : (long) (((100.0 * (double) total) / (double) all_time) + .5));