/* 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 <samuel@codesourcery.com>
- 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
+<http://www.gnu.org/licenses/>. */
#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
+#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. */
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
/* 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);
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;
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
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);
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. */
#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));
}
-