X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftimevar.c;h=d0aa15b5ca16269ae523f7cf421a07961e6b21b5;hb=0004970248290256b2b04d25acb3ac4634720ae3;hp=61fc92d21ce84b8a1d5d146fa4b55ce62a781b5d;hpb=74d2af64d63318d222416bac013bb32cbabb725c;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/timevar.c b/gcc/timevar.c index 61fc92d21ce..d0aa15b5ca1 100644 --- a/gcc/timevar.c +++ b/gcc/timevar.c @@ -1,33 +1,128 @@ /* Timing variables for measuring compiler performance. - Copyright (C) 2000 Free Software Foundation, Inc. + Copyright (C) 2000, 2003, 2004, 2005, 2007 Free Software Foundation, Inc. Contributed by Alex Samuel - This file is part of GNU CC. +This file is part of GCC. - GNU CC 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 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 3, or (at your option) any later +version. - GNU CC 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. +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 GNU CC; see the file COPYING. If not, write to - the Free Software Foundation, 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ #include "config.h" #include "system.h" - #ifdef HAVE_SYS_TIMES_H # include #endif +#ifdef HAVE_SYS_RESOURCE_H +#include +#endif +#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). */ +#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 + +/* 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; + +/* Total amount of memory allocated by garbage collector. */ + +size_t timevar_ggc_mem_total; + +/* The amount of memory that will cause us to report the timevar even + if the time spent is not significant. */ + +#define GGC_MEM_BOUND (1 << 20) + /* See timevar.h for an explanation of timing variables. */ /* A timing variable. */ @@ -41,12 +136,16 @@ struct timevar_def using timevar_start, this contains the start time. */ struct timevar_time_def start_time; - /* Non-zero if this timing variable is running as a standalone - timer. */ - int standalone; - /* 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 @@ -68,170 +167,110 @@ 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 - PARAMS ((struct timevar_time_def *)); -static void timevar_add - PARAMS ((struct timevar_time_def *, struct timevar_time_def *)); -static void timevar_accumulate - PARAMS ((struct timevar_time_def *, struct timevar_time_def *, - struct timevar_time_def *)); +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 - HAVA_WALL_TIME macros. */ + HAVE_WALL_TIME macros. */ static void -get_time (time) - struct timevar_time_def *time; +get_time (struct timevar_time_def *now) { - time->user = 0; - time->sys = 0; - time->wall = 0; - -#ifdef __BEOS__ - /* Nothing. */ -#else /* not BeOS */ -#if defined (_WIN32) && !defined (__CYGWIN__) - if (clock () >= 0) - time->user = clock () * 1000; -#define HAVE_USER_TIME - -#else /* not _WIN32 */ -#ifdef _SC_CLK_TCK - { - static int tick; - struct tms tms; - if (tick == 0) - tick = 1000000 / sysconf (_SC_CLK_TCK); - time->wall = times (&tms) * tick; - time->user = tms.tms_utime * tick; - time->sys = tms.tms_stime * tick; - } -#define HAVE_USER_TIME -#define HAVE_SYS_TIME -#define HAVE_WALL_TIME + now->user = 0; + now->sys = 0; + now->wall = 0; + now->ggc_mem = timevar_ggc_mem_total; -#else -#ifdef USG - { - struct tms tms; -# 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 -# define TICKS_PER_SECOND HZ /* traditional UNIX */ -# endif -# endif - time->wall = times (&tms) * (1000000 / TICKS_PER_SECOND); - time->user = tms.tms_utime * (1000000 / TICKS_PER_SECOND); - time->sys = tms.tms_stime * (1000000 / TICKS_PER_SECOND); - } -#define HAVE_USER_TIME -#define HAVE_SYS_TIME -#define HAVE_WALL_TIME + if (!timevar_enable) + return; -#else -#ifndef VMS { +#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 (0, &rusage); - time->user - = rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec; - time->sys - = rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec; - } -#define HAVE_USER_TIME -#define HAVE_SYS_TIME - -#else /* VMS */ - { - struct - { - int proc_user_time; - int proc_system_time; - int child_user_time; - int child_system_time; - } vms_times; - time->wall = times ((void *) &vms_times) * 10000; - time->user = vms_times.proc_user_time * 10000; - time->sys = vms_times.proc_system_time * 10000; + 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 } -#define HAVE_USER_TIME -#define HAVE_SYS_TIME -#define HAVE_WALL_TIME - -#endif /* VMS */ -#endif /* USG */ -#endif /* _SC_CLK_TCK */ -#endif /* _WIN32 */ -#endif /* __BEOS__ */ -} - -/* Add ELAPSED to TIMER. */ - -static void -timevar_add (timer, elapsed) - struct timevar_time_def *timer; - struct timevar_time_def *elapsed; -{ - timer->user += elapsed->user; - timer->sys += elapsed->sys; - timer->wall += elapsed->wall; } /* Add the difference between STOP_TIME and START_TIME to TIMER. */ -static void -timevar_accumulate (timer, start_time, stop_time) - struct timevar_time_def *timer; - struct timevar_time_def *start_time; - struct timevar_time_def *stop_time; +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; + timer->ggc_mem += stop_time->ggc_mem - start_time->ggc_mem; } /* Initialize timing variables. */ void -init_timevar (void) +timevar_init (void) { + timevar_enable = true; + /* Zero all elapsed times. */ - memset ((void *) timevars, 0, sizeof (timevars)); + memset (timevars, 0, sizeof (timevars)); /* Initialize the names of timing variables. */ -#define DEFTIMEVAR(identifer__, name__) \ - timevars[identifer__].name = name__; +#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 } /* 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. + popped or another element is pushed on top. TIMEVAR cannot be running as a standalone timer. */ void -timevar_push (timevar) - timevar_id_t timevar; +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. */ - if (tv->standalone) - abort (); + gcc_assert (!tv->standalone); /* What time is it? */ get_time (&now); @@ -242,12 +281,20 @@ timevar_push (timevar) timevar_accumulate (&stack->timevar->elapsed, &start_time, &now); /* Reset the start time; from now on, time is attributed to - TIMEVAR. */ + TIMEVAR. */ start_time = now; - /* Create a new stack element, and push it. */ - context = (struct timevar_stack_def *) - xmalloc (sizeof (struct timevar_stack_def)); + /* 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 = XNEW (struct timevar_stack_def); + + /* Fill it in and put it on the stack. */ context->timevar = tv; context->next = stack; stack = context; @@ -260,28 +307,30 @@ timevar_push (timevar) timing variable. */ void -timevar_pop (timevar) - timevar_id_t timevar; +timevar_pop_1 (timevar_id_t timevar) { struct timevar_time_def now; - struct timevar_stack_def *next = stack->next; - - if (&timevars[timevar] != stack->timevar) - abort (); + 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 (&stack->timevar->elapsed, &start_time, &now); + 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; - /* Remove the stack element. */ - free (stack); - stack = next; + /* 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 @@ -289,15 +338,19 @@ timevar_pop (timevar) attributed to TIMEVAR. */ void -timevar_start (timevar) - timevar_id_t timevar; +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. */ - if (tv->standalone) - abort (); + gcc_assert (!tv->standalone); tv->standalone = 1; get_time (&tv->start_time); @@ -307,64 +360,75 @@ timevar_start (timevar) is attributed to it. */ void -timevar_stop (timevar) - timevar_id_t timevar; +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. */ - if (!tv->standalone) - abort (); + gcc_assert (tv->standalone); get_time (&now); timevar_accumulate (&tv->elapsed, &tv->start_time, &now); } -/* Fill the elapsed time for TIMEVAR into ELAPSED. Returns - update-to-date information even if TIMEVAR is currently running. */ - -void -timevar_get (timevar, elapsed) - timevar_id_t timevar; - struct timevar_time_def *elapsed; -{ - struct timevar_def *tv = &timevars[timevar]; - - *elapsed = tv->elapsed; - - /* Is TIMEVAR currently running as a standalone timer? */ - if (tv->standalone) - /* Add the time elapsed since the it was started. */ - timevar_add (elapsed, &tv->start_time); - - /* Is TIMEVAR at the top of the timer stack? */ - if (stack->timevar == tv) - /* Add the elapsed time since it was pushed. */ - timevar_add (elapsed, &start_time); -} - /* 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 (fp) - FILE *fp; +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) - timevar_id_t id; + 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. */ - fprintf (fp, "\nExecution times (seconds)\n"); - for (id = 0; id < TIMEVAR_LAST; ++id) + 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[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 (id == TV_TOTAL) + 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 + && tv->elapsed.ggc_mem < GGC_MEM_BOUND) continue; /* The timing variable name. */ @@ -372,77 +436,71 @@ timevar_print (fp) #ifdef HAVE_USER_TIME /* Print user-mode time for this process. */ - fprintf (fp, "%4ld.%02ld (%2.0f%%) usr", - tv->elapsed.user / 1000000, - (tv->elapsed.user % 1000000) / 10000, - (total->user == 0) ? 0.0 - : (100.0 * tv->elapsed.user / (double) total->user)); + 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, "%4ld.%02ld (%2.0f%%) sys", - tv->elapsed.sys / 1000000, - (tv->elapsed.sys % 1000000) / 10000, - (total->sys == 0) ? 0.0 - : (100.0 * tv->elapsed.sys / (double) total->sys)); + 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, "%4ld.%02ld (%2.0f%%) wall", - tv->elapsed.wall / 1000000, - (tv->elapsed.wall % 1000000) / 10000, - (total->wall == 0) ? 0.0 - : (100.0 * tv->elapsed.wall / (double) total->wall)); + fprintf (fp, "%7.2f (%2.0f%%) wall", + tv->elapsed.wall, + (total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100); #endif /* HAVE_WALL_TIME */ - fprintf (fp, "\n"); + /* Print the amount of ggc memory allocated. */ + fprintf (fp, "%8u kB (%2.0f%%) ggc", + (unsigned) (tv->elapsed.ggc_mem >> 10), + (total->ggc_mem == 0 + ? 0 + : (float) tv->elapsed.ggc_mem / total->ggc_mem) * 100); + + putc ('\n', fp); } /* Print total time. */ - fprintf (fp, " TOTAL :"); + fputs (_(" TOTAL :"), fp); #ifdef HAVE_USER_TIME - fprintf (fp, "%4ld.%02ld ", - total->user / 1000000, (total->user % 1000000) / 10000); -#endif + fprintf (fp, "%7.2f ", total->user); +#endif #ifdef HAVE_SYS_TIME - fprintf (fp, "%4ld.%02ld ", - total->sys / 1000000, (total->sys % 1000000) / 10000); + fprintf (fp, "%7.2f ", total->sys); #endif #ifdef HAVE_WALL_TIME - fprintf (fp, "%4ld.%02ld\n", - total->wall / 1000000, (total->wall % 1000000) / 10000); + fprintf (fp, "%7.2f ", total->wall); #endif - -#endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME) - || defined (HAVE_WALL_TIME) */ -} + fprintf (fp, "%8u kB\n", (unsigned) (total->ggc_mem >> 10)); -/* Returns time (user + system) used so far by the compiler process, - in microseconds. */ +#ifdef ENABLE_CHECKING + fprintf (fp, "Extra diagnostic checks enabled; compiler may run slowly.\n"); + fprintf (fp, "Configure with --enable-checking=release to disable checks.\n"); +#endif +#ifndef ENABLE_ASSERT_CHECKING + fprintf (fp, "Internal checks disabled; compiler is not suited for release.\n"); + fprintf (fp, "Configure with --enable-checking=release to enable checks.\n"); +#endif -long -get_run_time () -{ - struct timevar_time_def total_elapsed; - timevar_get (TV_TOTAL, &total_elapsed); - return total_elapsed.user + total_elapsed.sys; +#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 (str, total) - const char *str; - long total; +print_time (const char *str, long total) { long all_time = get_run_time (); fprintf (stderr, - "time in %s: %ld.%06ld (%ld%%)\n", + _("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)); + all_time == 0 ? 0 + : (long) (((100.0 * (double) total) / (double) all_time) + .5)); } -