| /* Timing variables for measuring compiler performance. |
| Copyright (C) 2000, 2003, 2004 Free Software Foundation, Inc. |
| Contributed by Alex Samuel <samuel@codesourcery.com> |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 2, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING. If not, write to the Free |
| Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| 02111-1307, USA. */ |
| |
| #include "config.h" |
| #include "system.h" |
| #ifdef HAVE_SYS_TIMES_H |
| # include <sys/times.h> |
| #endif |
| #ifdef HAVE_SYS_RESOURCE_H |
| #include <sys/resource.h> |
| #endif |
| |
| /* APPLE LOCAL begin Mach time */ |
| #ifdef HAVE_MACH_MACH_TIME_H |
| #include <mach/mach_time.h> |
| #define HAVE_MACH_TIME 1 |
| static double timeBaseRatio; |
| static struct mach_timebase_info tbase; |
| #else |
| #define HAVE_MACH_TIME 0 |
| #endif |
| /* APPLE LOCAL end Mach time */ |
| #include "coretypes.h" |
| #include "tm.h" |
| #include "intl.h" |
| #include "rtl.h" |
| #include "toplev.h" |
| |
| #ifndef HAVE_CLOCK_T |
| typedef int clock_t; |
| #endif |
| |
| #ifndef HAVE_STRUCT_TMS |
| struct tms |
| { |
| clock_t tms_utime; |
| clock_t tms_stime; |
| clock_t tms_cutime; |
| clock_t tms_cstime; |
| }; |
| #endif |
| |
| #ifndef RUSAGE_SELF |
| # define RUSAGE_SELF 0 |
| #endif |
| |
| /* Calculation of scale factor to convert ticks to microseconds. |
| We mustn't use CLOCKS_PER_SEC except with clock(). */ |
| #if HAVE_SYSCONF && defined _SC_CLK_TCK |
| # define TICKS_PER_SECOND sysconf (_SC_CLK_TCK) /* POSIX 1003.1-1996 */ |
| #else |
| # ifdef CLK_TCK |
| # define TICKS_PER_SECOND CLK_TCK /* POSIX 1003.1-1988; obsolescent */ |
| # else |
| # ifdef HZ |
| # define TICKS_PER_SECOND HZ /* traditional UNIX */ |
| # else |
| # define TICKS_PER_SECOND 100 /* often the correct value */ |
| # endif |
| # endif |
| #endif |
| |
| /* Prefer times to getrusage to clock (each gives successively less |
| information). */ |
| /* APPLE LOCAL begin Mach time */ |
| /* On Darwin, prefer getrusage, plus Mach absolute time for the wall |
| clock time. Use PPC intrinsics if possible. */ |
| #if defined(__APPLE__) && defined(__POWERPC__) && HAVE_MACH_TIME |
| #if __POWERPC__ |
| # include "../more-hdrs/ppc_intrinsics.h" |
| # define HAVE_WALL_TIME |
| # define USE_PPC_INTRINSICS |
| static inline double |
| ppc_intrinsic_time (void) |
| { |
| unsigned long hi, lo; |
| do |
| { |
| hi = __mftbu(); |
| lo = __mftb(); |
| } while (hi != (unsigned long) __mftbu()); |
| return (hi * 0x100000000ull + lo) * timeBaseRatio; |
| } |
| #endif /* __POWERPC__ */ |
| #elif HAVE_MACH_TIME |
| # define USE_GETRUSAGE |
| # define USE_MACH_TIME |
| # define HAVE_USER_TIME |
| # define HAVE_SYS_TIME |
| # define HAVE_WALL_TIME |
| # else |
| /* APPLE LOCAL end Mach time */ |
| #ifdef HAVE_TIMES |
| # if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES |
| extern clock_t times (struct tms *); |
| # endif |
| # define USE_TIMES |
| # define HAVE_USER_TIME |
| # define HAVE_SYS_TIME |
| # define HAVE_WALL_TIME |
| #else |
| #ifdef HAVE_GETRUSAGE |
| # if defined HAVE_DECL_GETRUSAGE && !HAVE_DECL_GETRUSAGE |
| extern int getrusage (int, struct rusage *); |
| # endif |
| # define USE_GETRUSAGE |
| # define HAVE_USER_TIME |
| # define HAVE_SYS_TIME |
| #else |
| #ifdef HAVE_CLOCK |
| # if defined HAVE_DECL_CLOCK && !HAVE_DECL_CLOCK |
| extern clock_t clock (void); |
| # endif |
| # define USE_CLOCK |
| # define HAVE_USER_TIME |
| #endif |
| #endif |
| #endif |
| /* APPLE LOCAL Mach time */ |
| #endif /* HAVE_MACH_TIME */ |
| |
| /* libc is very likely to have snuck a call to sysconf() into one of |
| the underlying constants, and that can be very slow, so we have to |
| precompute them. Whose wonderful idea was it to make all those |
| _constants_ variable at run time, anyway? */ |
| #ifdef USE_TIMES |
| static double ticks_to_msec; |
| #define TICKS_TO_MSEC (1 / (double)TICKS_PER_SECOND) |
| #endif |
| |
| #ifdef USE_CLOCK |
| static double clocks_to_msec; |
| #define CLOCKS_TO_MSEC (1 / (double)CLOCKS_PER_SEC) |
| #endif |
| |
| #include "flags.h" |
| #include "timevar.h" |
| |
| bool timevar_enable; |
| |
| /* See timevar.h for an explanation of timing variables. */ |
| |
| /* A timing variable. */ |
| |
| struct timevar_def |
| { |
| /* Elapsed time for this variable. */ |
| struct timevar_time_def elapsed; |
| |
| /* If this variable is timed independently of the timing stack, |
| using timevar_start, this contains the start time. */ |
| struct timevar_time_def start_time; |
| |
| /* The name of this timing variable. */ |
| const char *name; |
| |
| /* Nonzero if this timing variable is running as a standalone |
| timer. */ |
| unsigned standalone : 1; |
| |
| /* Nonzero if this timing variable was ever started or pushed onto |
| the timing stack. */ |
| unsigned used : 1; |
| }; |
| |
| /* An element on the timing stack. Elapsed time is attributed to the |
| topmost timing variable on the stack. */ |
| |
| struct timevar_stack_def |
| { |
| /* The timing variable at this stack level. */ |
| struct timevar_def *timevar; |
| |
| /* The next lower timing variable context in the stack. */ |
| struct timevar_stack_def *next; |
| }; |
| |
| /* Declared timing variables. Constructed from the contents of |
| timevar.def. */ |
| static struct timevar_def timevars[TIMEVAR_LAST]; |
| |
| /* The top of the timing stack. */ |
| static struct timevar_stack_def *stack; |
| |
| /* A list of unused (i.e. allocated and subsequently popped) |
| timevar_stack_def instances. */ |
| static struct timevar_stack_def *unused_stack_instances; |
| |
| /* The time at which the topmost element on the timing stack was |
| pushed. Time elapsed since then is attributed to the topmost |
| element. */ |
| static struct timevar_time_def start_time; |
| |
| static void get_time (struct timevar_time_def *); |
| static void timevar_accumulate (struct timevar_time_def *, |
| struct timevar_time_def *, |
| struct timevar_time_def *); |
| |
| /* Fill the current times into TIME. The definition of this function |
| also defines any or all of the HAVE_USER_TIME, HAVE_SYS_TIME, and |
| HAVE_WALL_TIME macros. */ |
| |
| static void |
| get_time (struct timevar_time_def *now) |
| { |
| now->user = 0; |
| now->sys = 0; |
| now->wall = 0; |
| |
| if (!timevar_enable) |
| return; |
| |
| { |
| #ifdef USE_TIMES |
| struct tms tms; |
| now->wall = times (&tms) * ticks_to_msec; |
| now->user = tms.tms_utime * ticks_to_msec; |
| now->sys = tms.tms_stime * ticks_to_msec; |
| #endif |
| #ifdef USE_GETRUSAGE |
| struct rusage rusage; |
| getrusage (RUSAGE_SELF, &rusage); |
| now->user = rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec * 1e-6; |
| now->sys = rusage.ru_stime.tv_sec + rusage.ru_stime.tv_usec * 1e-6; |
| #endif |
| #ifdef USE_CLOCK |
| now->user = clock () * clocks_to_msec; |
| #endif |
| /* APPLE LOCAL begin Mach time */ |
| #ifdef USE_MACH_TIME |
| now->wall = mach_absolute_time() * timeBaseRatio; |
| #endif |
| #ifdef USE_PPC_INTRINSICS |
| now->wall = ppc_intrinsic_time(); |
| #endif |
| /* APPLE LOCAL end Mach time */ |
| } |
| } |
| |
| /* Add the difference between STOP_TIME and START_TIME to TIMER. */ |
| |
| static void |
| timevar_accumulate (struct timevar_time_def *timer, |
| struct timevar_time_def *start_time, |
| struct timevar_time_def *stop_time) |
| { |
| timer->user += stop_time->user - start_time->user; |
| timer->sys += stop_time->sys - start_time->sys; |
| timer->wall += stop_time->wall - start_time->wall; |
| } |
| |
| /* Initialize timing variables. */ |
| |
| void |
| timevar_init (void) |
| { |
| timevar_enable = true; |
| |
| /* Zero all elapsed times. */ |
| memset (timevars, 0, sizeof (timevars)); |
| |
| /* Initialize the names of timing variables. */ |
| #define DEFTIMEVAR(identifier__, name__) \ |
| timevars[identifier__].name = name__; |
| #include "timevar.def" |
| #undef DEFTIMEVAR |
| |
| #ifdef USE_TIMES |
| ticks_to_msec = TICKS_TO_MSEC; |
| #endif |
| #ifdef USE_CLOCK |
| clocks_to_msec = CLOCKS_TO_MSEC; |
| #endif |
| /* APPLE LOCAL begin Mach time */ |
| #if defined(USE_MACH_TIME) || defined(USE_PPC_INTRINSICS) |
| mach_timebase_info(&tbase); |
| timeBaseRatio = ((double) tbase.numer / (double) tbase.denom) * 1e-9; |
| #endif |
| /* APPLE LOCAL end Mach time */ |
| } |
| |
| /* Push TIMEVAR onto the timing stack. No further elapsed time is |
| attributed to the previous topmost timing variable on the stack; |
| subsequent elapsed time is attributed to TIMEVAR, until it is |
| popped or another element is pushed on top. |
| |
| TIMEVAR cannot be running as a standalone timer. */ |
| |
| void |
| timevar_push_1 (timevar_id_t timevar) |
| { |
| struct timevar_def *tv = &timevars[timevar]; |
| struct timevar_stack_def *context; |
| struct timevar_time_def now; |
| |
| /* Mark this timing variable as used. */ |
| tv->used = 1; |
| |
| /* Can't push a standalone timer. */ |
| gcc_assert (!tv->standalone); |
| |
| /* What time is it? */ |
| get_time (&now); |
| |
| /* If the stack isn't empty, attribute the current elapsed time to |
| the old topmost element. */ |
| if (stack) |
| timevar_accumulate (&stack->timevar->elapsed, &start_time, &now); |
| |
| /* Reset the start time; from now on, time is attributed to |
| TIMEVAR. */ |
| start_time = now; |
| |
| /* See if we have a previously-allocated stack instance. If so, |
| take it off the list. If not, malloc a new one. */ |
| if (unused_stack_instances != NULL) |
| { |
| context = unused_stack_instances; |
| unused_stack_instances = unused_stack_instances->next; |
| } |
| else |
| context = xmalloc (sizeof (struct timevar_stack_def)); |
| |
| /* Fill it in and put it on the stack. */ |
| context->timevar = tv; |
| context->next = stack; |
| stack = context; |
| } |
| |
| /* Pop the topmost timing variable element off the timing stack. The |
| popped variable must be TIMEVAR. Elapsed time since the that |
| element was pushed on, or since it was last exposed on top of the |
| stack when the element above it was popped off, is credited to that |
| timing variable. */ |
| |
| void |
| timevar_pop_1 (timevar_id_t timevar) |
| { |
| struct timevar_time_def now; |
| struct timevar_stack_def *popped = stack; |
| |
| gcc_assert (&timevars[timevar] == stack->timevar); |
| |
| /* What time is it? */ |
| get_time (&now); |
| |
| /* Attribute the elapsed time to the element we're popping. */ |
| timevar_accumulate (&popped->timevar->elapsed, &start_time, &now); |
| |
| /* Reset the start time; from now on, time is attributed to the |
| element just exposed on the stack. */ |
| start_time = now; |
| |
| /* Take the item off the stack. */ |
| stack = stack->next; |
| |
| /* Don't delete the stack element; instead, add it to the list of |
| unused elements for later use. */ |
| popped->next = unused_stack_instances; |
| unused_stack_instances = popped; |
| } |
| |
| /* Start timing TIMEVAR independently of the timing stack. Elapsed |
| time until timevar_stop is called for the same timing variable is |
| attributed to TIMEVAR. */ |
| |
| void |
| timevar_start (timevar_id_t timevar) |
| { |
| struct timevar_def *tv = &timevars[timevar]; |
| |
| if (!timevar_enable) |
| return; |
| |
| /* Mark this timing variable as used. */ |
| tv->used = 1; |
| |
| /* Don't allow the same timing variable to be started more than |
| once. */ |
| gcc_assert (!tv->standalone); |
| tv->standalone = 1; |
| |
| get_time (&tv->start_time); |
| } |
| |
| /* Stop timing TIMEVAR. Time elapsed since timevar_start was called |
| is attributed to it. */ |
| |
| void |
| timevar_stop (timevar_id_t timevar) |
| { |
| struct timevar_def *tv = &timevars[timevar]; |
| struct timevar_time_def now; |
| |
| if (!timevar_enable) |
| return; |
| |
| /* TIMEVAR must have been started via timevar_start. */ |
| gcc_assert (tv->standalone); |
| |
| get_time (&now); |
| timevar_accumulate (&tv->elapsed, &tv->start_time, &now); |
| } |
| |
| /* Summarize timing variables to FP. The timing variable TV_TOTAL has |
| a special meaning -- it's considered to be the total elapsed time, |
| for normalizing the others, and is displayed last. */ |
| |
| void |
| timevar_print (FILE *fp) |
| { |
| /* Only print stuff if we have some sort of time information. */ |
| #if defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME) || defined (HAVE_WALL_TIME) |
| unsigned int /* timevar_id_t */ id; |
| struct timevar_time_def *total = &timevars[TV_TOTAL].elapsed; |
| struct timevar_time_def now; |
| |
| if (!timevar_enable) |
| return; |
| |
| /* Update timing information in case we're calling this from GDB. */ |
| |
| if (fp == 0) |
| fp = stderr; |
| |
| /* What time is it? */ |
| get_time (&now); |
| |
| /* If the stack isn't empty, attribute the current elapsed time to |
| the old topmost element. */ |
| if (stack) |
| timevar_accumulate (&stack->timevar->elapsed, &start_time, &now); |
| |
| /* Reset the start time; from now on, time is attributed to |
| TIMEVAR. */ |
| start_time = now; |
| |
| fputs (_("\nExecution times (seconds)\n"), fp); |
| for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id) |
| { |
| struct timevar_def *tv = &timevars[(timevar_id_t) id]; |
| const double tiny = 5e-3; |
| |
| /* Don't print the total execution time here; that goes at the |
| end. */ |
| if ((timevar_id_t) id == TV_TOTAL) |
| continue; |
| |
| /* Don't print timing variables that were never used. */ |
| if (!tv->used) |
| continue; |
| |
| /* Don't print timing variables if we're going to get a row of |
| zeroes. */ |
| if (tv->elapsed.user < tiny |
| && tv->elapsed.sys < tiny |
| && tv->elapsed.wall < tiny) |
| continue; |
| |
| /* The timing variable name. */ |
| fprintf (fp, " %-22s:", tv->name); |
| |
| #ifdef HAVE_USER_TIME |
| /* Print user-mode time for this process. */ |
| fprintf (fp, "%7.2f (%2.0f%%) usr", |
| tv->elapsed.user, |
| (total->user == 0 ? 0 : tv->elapsed.user / total->user) * 100); |
| #endif /* HAVE_USER_TIME */ |
| |
| #ifdef HAVE_SYS_TIME |
| /* Print system-mode time for this process. */ |
| fprintf (fp, "%7.2f (%2.0f%%) sys", |
| tv->elapsed.sys, |
| (total->sys == 0 ? 0 : tv->elapsed.sys / total->sys) * 100); |
| #endif /* HAVE_SYS_TIME */ |
| |
| #ifdef HAVE_WALL_TIME |
| /* Print wall clock time elapsed. */ |
| fprintf (fp, "%7.2f (%2.0f%%) wall", |
| tv->elapsed.wall, |
| (total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100); |
| #endif /* HAVE_WALL_TIME */ |
| |
| putc ('\n', fp); |
| } |
| |
| /* Print total time. */ |
| fputs (_(" TOTAL :"), fp); |
| #ifdef HAVE_USER_TIME |
| /* APPLE LOCAL time formatting */ |
| fprintf (fp, "%7.2f", total->user); |
| #endif |
| #ifdef HAVE_SYS_TIME |
| /* APPLE LOCAL time formatting */ |
| fprintf (fp, " %7.2f", total->sys); |
| #endif |
| #ifdef HAVE_WALL_TIME |
| /* APPLE LOCAL time formatting */ |
| fprintf (fp, " %7.2f", total->wall); |
| #endif |
| /* APPLE LOCAL time formatting */ |
| putc ('\n', fp); |
| |
| #ifdef ENABLE_CHECKING |
| fprintf (fp, "Extra diagnostic checks enabled; compiler may run slowly.\n"); |
| fprintf (fp, "Configure with --disable-checking to disable checks.\n"); |
| #endif |
| |
| #endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME) |
| || defined (HAVE_WALL_TIME) */ |
| } |
| |
| /* Prints a message to stderr stating that time elapsed in STR is |
| TOTAL (given in microseconds). */ |
| |
| void |
| print_time (const char *str, long total) |
| { |
| long all_time = get_run_time (); |
| fprintf (stderr, |
| _("time in %s: %ld.%06ld (%ld%%)\n"), |
| str, total / 1000000, total % 1000000, |
| all_time == 0 ? 0 |
| : (long) (((100.0 * (double) total) / (double) all_time) + .5)); |
| } |