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