/* Timing variables for measuring compiler performance.
- Copyright (C) 2000 Free Software Foundation, Inc.
+ Copyright (C) 2000-2016 Free Software Foundation, Inc.
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 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.
- 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.
+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. */
+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"
-#include "intl.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 "timevar.h"
+#include "options.h"
#ifndef HAVE_CLOCK_T
typedef int clock_t;
};
#endif
-#if defined HAVE_DECL_GETRUSAGE && !HAVE_DECL_GETRUSAGE
-extern int getrusage PARAMS ((int, struct rusage *));
-#endif
-#if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES
-extern clock_t times PARAMS ((struct tms *));
-#endif
-#if defined HAVE_DECL_CLOCK && !HAVE_DECL_CLOCK
-extern clock_t clock PARAMS ((void));
-#endif
-
#ifndef RUSAGE_SELF
# define RUSAGE_SELF 0
#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
precompute them. Whose wonderful idea was it to make all those
_constants_ variable at run time, anyway? */
#ifdef USE_TIMES
-static float ticks_to_msec;
-#define TICKS_TO_MSEC (1 / (float)TICKS_PER_SECOND)
+static double ticks_to_msec;
+#define TICKS_TO_MSEC (1 / (double)TICKS_PER_SECOND)
#endif
#ifdef USE_CLOCK
-static float clocks_to_msec;
-#define CLOCKS_TO_MSEC (1 / (float)CLOCKS_PER_SEC)
+static double clocks_to_msec;
+#define CLOCKS_TO_MSEC (1 / (double)CLOCKS_PER_SEC)
#endif
-#include "flags.h"
-#include "timevar.h"
+/* Non-NULL if timevars should be used. In GCC, this happens with
+ the -ftime-report flag. */
-/* See timevar.h for an explanation of timing variables. */
+timer *g_timer;
-/* This macro evaluates to non-zero if timing variables are enabled. */
-#define TIMEVAR_ENABLE (time_report)
+/* Total amount of memory allocated by garbage collector. */
-/* A timing variable. */
+size_t timevar_ggc_mem_total;
-struct timevar_def
-{
- /* Elapsed time for this variable. */
- struct timevar_time_def elapsed;
+/* 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)
- /* If this variable is timed independently of the timing stack,
- using timevar_start, this contains the start time. */
- struct timevar_time_def start_time;
+/* See timevar.h for an explanation of timing variables. */
- /* The name of this timing variable. */
- const char *name;
+static void get_time (struct timevar_time_def *);
+static void timevar_accumulate (struct timevar_time_def *,
+ struct timevar_time_def *,
+ struct timevar_time_def *);
- /* Non-zero if this timing variable is running as a standalone
- timer. */
- unsigned standalone : 1;
+/* The implementation of timing events for jit client code, allowing
+ arbitrary named items to appear on the timing stack. */
- /* Non-zero if this timing variable was ever started or pushed onto
- the timing stack. */
- unsigned used : 1;
+class timer::named_items
+{
+ public:
+ named_items (timer *t);
+ ~named_items ();
+
+ void push (const char *item_name);
+ void pop ();
+ void print (FILE *fp, const timevar_time_def *total);
+
+ private:
+ /* Which timer instance does this relate to? */
+ timer *m_timer;
+
+ /* Dictionary, mapping from item names to timevar_def.
+ Note that currently we merely store/compare the raw string
+ pointers provided by client code; we don't take a copy,
+ or use strcmp. */
+ hash_map <const char *, timer::timevar_def> m_hash_map;
+
+ /* The order in which items were originally inserted. */
+ auto_vec <const char *> m_names;
};
-/* An element on the timing stack. Elapsed time is attributed to the
- topmost timing variable on the stack. */
+/* The constructor for class timer::named_items. */
-struct timevar_stack_def
+timer::named_items::named_items (timer *t)
+: m_timer (t),
+ m_hash_map (),
+ m_names ()
{
- /* 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;
-};
+/* The destructor for class timer::named_items. */
+
+timer::named_items::~named_items ()
+{
+}
+
+/* Push the named item onto the timer stack. */
-/* Declared timing variables. Constructed from the contents of
- timevar.def. */
-static struct timevar_def timevars[TIMEVAR_LAST];
+void
+timer::named_items::push (const char *item_name)
+{
+ gcc_assert (item_name);
-/* The top of the timing stack. */
-static struct timevar_stack_def *stack;
+ bool existed;
+ timer::timevar_def *def = &m_hash_map.get_or_insert (item_name, &existed);
+ if (!existed)
+ {
+ def->elapsed.user = 0;
+ def->elapsed.sys = 0;
+ def->elapsed.wall = 0;
+ def->name = item_name;
+ def->standalone = 0;
+ m_names.safe_push (item_name);
+ }
+ m_timer->push_internal (def);
+}
-/* A list of unused (i.e. allocated and subsequently popped)
- timevar_stack_def instances. */
-static struct timevar_stack_def *unused_stack_instances;
+/* Pop the top item from the timer stack. */
-/* 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;
+void
+timer::named_items::pop ()
+{
+ m_timer->pop_internal ();
+}
-static void get_time
- PARAMS ((struct timevar_time_def *));
-static void timevar_accumulate
- PARAMS ((struct timevar_time_def *, struct timevar_time_def *,
- struct timevar_time_def *));
+/* Print the given client item. Helper function for timer::print. */
+
+void
+timer::named_items::print (FILE *fp, const timevar_time_def *total)
+{
+ unsigned int i;
+ const char *item_name;
+ fprintf (fp, "Client items:\n");
+ FOR_EACH_VEC_ELT (m_names, i, item_name)
+ {
+ timer::timevar_def *def = m_hash_map.get (item_name);
+ gcc_assert (def);
+ m_timer->print_row (fp, total, 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 (now)
- struct timevar_time_def *now;
+get_time (struct timevar_time_def *now)
{
now->user = 0;
now->sys = 0;
now->wall = 0;
-
- if (!TIMEVAR_ENABLE)
- return;
+ now->ggc_mem = timevar_ggc_mem_total;
{
#ifdef USE_TIMES
/* 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. */
+/* Class timer's constructor. */
-void
-init_timevar ()
+timer::timer () :
+ m_stack (NULL),
+ m_unused_stack_instances (NULL),
+ m_start_time (),
+ m_jit_client_items (NULL)
{
- if (!TIMEVAR_ENABLE)
- return;
-
/* Zero all elapsed times. */
- memset ((void *) timevars, 0, sizeof (timevars));
+ memset (m_timevars, 0, sizeof (m_timevars));
/* Initialize the names of timing variables. */
-#define DEFTIMEVAR(identifer__, name__) \
- timevars[identifer__].name = name__;
+#define DEFTIMEVAR(identifier__, name__) \
+ m_timevars[identifier__].name = name__;
#include "timevar.def"
#undef DEFTIMEVAR
+ /* Initialize configuration-specific state.
+ Ideally this would be one-time initialization. */
#ifdef USE_TIMES
ticks_to_msec = TICKS_TO_MSEC;
#endif
#endif
}
+/* Class timer's destructor. */
+
+timer::~timer ()
+{
+ timevar_stack_def *iter, *next;
+
+ for (iter = m_stack; iter; iter = next)
+ {
+ next = iter->next;
+ free (iter);
+ }
+ for (iter = m_unused_stack_instances; iter; iter = next)
+ {
+ next = iter->next;
+ free (iter);
+ }
+
+ delete m_jit_client_items;
+}
+
+/* Initialize timing variables. */
+
+void
+timevar_init (void)
+{
+ if (g_timer)
+ return;
+
+ g_timer = new timer ();
+}
+
/* 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;
+timer::push (timevar_id_t timevar)
+{
+ struct timevar_def *tv = &m_timevars[timevar];
+ push_internal (tv);
+}
+
+/* Push TV onto the timing stack, either one of the builtin ones
+ for a timevar_id_t, or one provided by client code to libgccjit. */
+
+void
+timer::push_internal (struct timevar_def *tv)
{
- struct timevar_def *tv = &timevars[timevar];
struct timevar_stack_def *context;
struct timevar_time_def now;
- if (!TIMEVAR_ENABLE)
- return;
+ gcc_assert (tv);
/* 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);
/* 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);
+ if (m_stack)
+ timevar_accumulate (&m_stack->timevar->elapsed, &m_start_time, &now);
/* Reset the start time; from now on, time is attributed to
TIMEVAR. */
- start_time = now;
+ m_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)
+ if (m_unused_stack_instances != NULL)
{
- context = unused_stack_instances;
- unused_stack_instances = unused_stack_instances->next;
+ context = m_unused_stack_instances;
+ m_unused_stack_instances = m_unused_stack_instances->next;
}
else
- context = (struct timevar_stack_def *)
- xmalloc (sizeof (struct timevar_stack_def));
+ context = XNEW (struct timevar_stack_def);
/* Fill it in and put it on the stack. */
context->timevar = tv;
- context->next = stack;
- stack = context;
+ context->next = m_stack;
+ m_stack = context;
}
/* Pop the topmost timing variable element off the timing stack. The
timing variable. */
void
-timevar_pop (timevar)
- timevar_id_t timevar;
+timer::pop (timevar_id_t timevar)
{
- struct timevar_time_def now;
- struct timevar_stack_def *popped = stack;
+ gcc_assert (&m_timevars[timevar] == m_stack->timevar);
- if (!TIMEVAR_ENABLE)
- return;
+ pop_internal ();
+}
- if (&timevars[timevar] != stack->timevar)
- abort ();
+/* Pop the topmost item from the stack, either one of the builtin ones
+ for a timevar_id_t, or one provided by client code to libgccjit. */
+
+void
+timer::pop_internal ()
+{
+ struct timevar_time_def now;
+ struct timevar_stack_def *popped = m_stack;
/* 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);
+ timevar_accumulate (&popped->timevar->elapsed, &m_start_time, &now);
/* Reset the start time; from now on, time is attributed to the
element just exposed on the stack. */
- start_time = now;
+ m_start_time = now;
/* Take the item off the stack. */
- stack = stack->next;
+ m_stack = m_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;
+ popped->next = m_unused_stack_instances;
+ m_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)
+ if (!g_timer)
return;
+ g_timer->start (timevar);
+}
+
+/* See timevar_start above. */
+
+void
+timer::start (timevar_id_t timevar)
+{
+ struct timevar_def *tv = &m_timevars[timevar];
+
/* 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)
+ if (!g_timer)
return;
+ g_timer->stop (timevar);
+}
+
+/* See timevar_stop above. */
+
+void
+timer::stop (timevar_id_t timevar)
+{
+ struct timevar_def *tv = &m_timevars[timevar];
+ struct timevar_time_def now;
+
/* TIMEVAR must have been started via timevar_start. */
- if (!tv->standalone)
- abort ();
+ gcc_assert (tv->standalone);
+ tv->standalone = 0; /* Enable a restart. */
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. */
+
+/* Conditionally start timing TIMEVAR independently of the timing stack.
+ If the timer is already running, leave it running and return true.
+ Otherwise, start the timer and return false.
+ Elapsed time until the corresponding timevar_cond_stop
+ is called for the same timing variable is attributed to TIMEVAR. */
+
+bool
+timevar_cond_start (timevar_id_t timevar)
+{
+ if (!g_timer)
+ return false;
+
+ return g_timer->cond_start (timevar);
+}
+
+/* See timevar_cond_start above. */
+
+bool
+timer::cond_start (timevar_id_t timevar)
+{
+ struct timevar_def *tv = &m_timevars[timevar];
+
+ /* Mark this timing variable as used. */
+ tv->used = 1;
+
+ if (tv->standalone)
+ return true; /* The timevar is already running. */
+
+ /* Don't allow the same timing variable
+ to be unconditionally started more than once. */
+ tv->standalone = 1;
+
+ get_time (&tv->start_time);
+ return false; /* The timevar was not already running. */
+}
+
+/* Conditionally stop timing TIMEVAR. The RUNNING parameter must come
+ from the return value of a dynamically matching timevar_cond_start.
+ If the timer had already been RUNNING, do nothing. Otherwise, time
+ elapsed since timevar_cond_start was called is attributed to it. */
+
+void
+timevar_cond_stop (timevar_id_t timevar, bool running)
+{
+ if (!g_timer || running)
+ return;
+
+ g_timer->cond_stop (timevar);
+}
+
+/* See timevar_cond_stop above. */
void
-timevar_get (timevar, elapsed)
- timevar_id_t timevar;
- struct timevar_time_def *elapsed;
+timer::cond_stop (timevar_id_t timevar)
{
- struct timevar_def *tv = &timevars[timevar];
+ struct timevar_def *tv;
struct timevar_time_def now;
- *elapsed = tv->elapsed;
-
- /* Is TIMEVAR currently running as a standalone timer? */
- if (tv->standalone)
+ tv = &m_timevars[timevar];
+
+ /* TIMEVAR must have been started via timevar_cond_start. */
+ gcc_assert (tv->standalone);
+ tv->standalone = 0; /* Enable a restart. */
+
+ get_time (&now);
+ timevar_accumulate (&tv->elapsed, &tv->start_time, &now);
+}
+
+/* Push the named item onto the timing stack. */
+
+void
+timer::push_client_item (const char *item_name)
+{
+ gcc_assert (item_name);
+
+ /* Lazily create the named_items instance. */
+ if (!m_jit_client_items)
+ m_jit_client_items = new named_items (this);
+
+ m_jit_client_items->push (item_name);
+}
+
+/* Pop the top-most client item from the timing stack. */
+
+void
+timer::pop_client_item ()
+{
+ gcc_assert (m_jit_client_items);
+ m_jit_client_items->pop ();
+}
+
+/* Validate that phase times are consistent. */
+
+void
+timer::validate_phases (FILE *fp) const
+{
+ unsigned int /* timevar_id_t */ id;
+ const timevar_time_def *total = &m_timevars[TV_TOTAL].elapsed;
+ double phase_user = 0.0;
+ double phase_sys = 0.0;
+ double phase_wall = 0.0;
+ size_t phase_ggc_mem = 0;
+ static char phase_prefix[] = "phase ";
+ const double tolerance = 1.000001; /* One part in a million. */
+
+ for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id)
{
- get_time (&now);
- timevar_accumulate (elapsed, &tv->start_time, &now);
+ const timevar_def *tv = &m_timevars[(timevar_id_t) id];
+
+ /* Don't evaluate timing variables that were never used. */
+ if (!tv->used)
+ continue;
+
+ if (strncmp (tv->name, phase_prefix, sizeof phase_prefix - 1) == 0)
+ {
+ phase_user += tv->elapsed.user;
+ phase_sys += tv->elapsed.sys;
+ phase_wall += tv->elapsed.wall;
+ phase_ggc_mem += tv->elapsed.ggc_mem;
+ }
}
- /* Or is TIMEVAR at the top of the timer stack? */
- else if (stack->timevar == tv)
+
+ if (phase_user > total->user * tolerance
+ || phase_sys > total->sys * tolerance
+ || phase_wall > total->wall * tolerance
+ || phase_ggc_mem > total->ggc_mem * tolerance)
{
- get_time (&now);
- timevar_accumulate (elapsed, &start_time, &now);
+
+ fprintf (fp, "Timing error: total of phase timers exceeds total time.\n");
+ if (phase_user > total->user)
+ fprintf (fp, "user %24.18e > %24.18e\n", phase_user, total->user);
+ if (phase_sys > total->sys)
+ fprintf (fp, "sys %24.18e > %24.18e\n", phase_sys, total->sys);
+ if (phase_wall > total->wall)
+ fprintf (fp, "wall %24.18e > %24.18e\n", phase_wall, total->wall);
+ if (phase_ggc_mem > total->ggc_mem)
+ fprintf (fp, "ggc_mem %24lu > %24lu\n", (unsigned long)phase_ggc_mem,
+ (unsigned long)total->ggc_mem);
+ gcc_unreachable ();
}
}
+/* Helper function for timer::print. */
+
+void
+timer::print_row (FILE *fp,
+ const timevar_time_def *total,
+ const timevar_def *tv)
+{
+ /* The timing variable name. */
+ fprintf (fp, " %-24s:", 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 */
+
+ /* 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);
+}
+
/* 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;
+timer::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;
+ const timevar_time_def *total = &m_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)
/* 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);
+ if (m_stack)
+ timevar_accumulate (&m_stack->timevar->elapsed, &m_start_time, &now);
/* Reset the start time; from now on, time is attributed to
TIMEVAR. */
- start_time = now;
+ m_start_time = now;
- fputs (_("\nExecution times (seconds)\n"), fp);
+ fputs ("\nExecution times (seconds)\n", fp);
+ if (m_jit_client_items)
+ fputs ("GCC items:\n", fp);
for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id)
{
- struct timevar_def *tv = &timevars[(timevar_id_t) id];
- const float tiny = 5e-3;
+ const timevar_def *tv = &m_timevars[(timevar_id_t) id];
+ const double tiny = 5e-3;
/* Don't print the total execution time here; that goes at the
end. */
zeroes. */
if (tv->elapsed.user < tiny
&& tv->elapsed.sys < tiny
- && tv->elapsed.wall < tiny)
+ && tv->elapsed.wall < tiny
+ && tv->elapsed.ggc_mem < GGC_MEM_BOUND)
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_row (fp, total, tv);
}
+ if (m_jit_client_items)
+ m_jit_client_items->print (fp, total);
/* Print total time. */
- fputs (_(" TOTAL :"), fp);
+ fputs (" TOTAL :", fp);
#ifdef HAVE_USER_TIME
fprintf (fp, "%7.2f ", total->user);
-#endif
+#endif
#ifdef HAVE_SYS_TIME
fprintf (fp, "%7.2f ", total->sys);
#endif
#ifdef HAVE_WALL_TIME
- fprintf (fp, "%7.2f\n", total->wall);
+ fprintf (fp, "%7.2f ", total->wall);
#endif
-
-#endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
+ fprintf (fp, "%8u kB\n", (unsigned) (total->ggc_mem >> 10));
+
+ if (CHECKING_P || flag_checking)
+ fprintf (fp, "Extra diagnostic checks enabled; compiler may run slowly.\n");
+ if (CHECKING_P)
+ fprintf (fp, "Configure with --enable-checking=release to disable checks.\n");
+#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
+
+#endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
|| defined (HAVE_WALL_TIME) */
-}
-/* Returns time (user + system) used so far by the compiler process,
- in microseconds. */
+ validate_phases (fp);
+}
-long
-get_run_time ()
+/* Get the name of the topmost item. For use by jit for validating
+ inputs to gcc_jit_timer_pop. */
+const char *
+timer::get_topmost_item_name () const
{
- struct timevar_time_def total_elapsed;
- timevar_get (TV_TOTAL, &total_elapsed);
- return total_elapsed.user + total_elapsed.sys;
+ if (m_stack)
+ return m_stack->timevar->name;
+ else
+ return NULL;
}
/* 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));
}