+2002-07-31 Akim Demaille <akim@epita.fr>
+
+ Steal GCC's --time-report support.
+
+ * lib/timevar.c, lib/timevar.h, lib/timevar.def: New,
+ stolen/adjusted from GCC.
+ * m4/stage.m4: Remove time related checks.
+ * m4/timevar.m4: New.
+ * configure.in: Adjust.
+ * src/system.h: Adjust to using timevar.h.
+ * src/getargs.h, src/getargs.c: Support trace_time for
+ --trace=time.
+ * src/main.c (stage): Remove.
+ (main): Replace `stage' invocations with timevar calls.
+ * src/output.c: Insert pertinent timevar calls.
+
2002-07-31 Akim Demaille <akim@epita.fr>
Let --trace have arguments.
jm_PREREQ_QUOTEARG
jm_PREREQ_ERROR
AM_WITH_DMALLOC
+BISON_PREREQ_TIMEVAR
BISON_PREREQ_STAGE
# Gettext.
libbison_a_SOURCES += \
bitsetv-print.h bitsetv-print.c
+# timevars, stolen from GCC.
+libbison_a_SOURCES += \
+ timevar.h timevar.c timevar.def
+
libbison_a_LIBADD = @LIBOBJS@ @ALLOCA@
libbison_a_DEPENDENCIES = $(libbison_a_LIBADD)
--- /dev/null
+/* Timing variables for measuring compiler performance.
+ Copyright (C) 2000 Free Software Foundation, Inc.
+ Contributed by Alex Samuel <samuel@codesourcery.com>
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
+
+#if IN_GCC
+
+/* These are the original includes --akim. */
+#include "config.h"
+#include "system.h"
+#include "intl.h"
+#include "rtl.h"
+
+#else
+
+/* These are my replacements by hand --akim.
+ There is another change below, flag with IN_GCC. */
+# include "../src/system.h"
+int time_report = 0;
+
+#endif
+
+
+#ifdef HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+
+#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
+
+#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
+
+/* 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
+# define USE_TIMES
+# define HAVE_USER_TIME
+# define HAVE_SYS_TIME
+# define HAVE_WALL_TIME
+#else
+#ifdef HAVE_GETRUSAGE
+# define USE_GETRUSAGE
+# define HAVE_USER_TIME
+# define HAVE_SYS_TIME
+#else
+#ifdef HAVE_CLOCK
+# 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 float ticks_to_msec;
+#define TICKS_TO_MSEC (1 / (float)TICKS_PER_SECOND)
+#endif
+
+#ifdef USE_CLOCK
+static float clocks_to_msec;
+#define CLOCKS_TO_MSEC (1 / (float)CLOCKS_PER_SEC)
+#endif
+
+#if IN_GCC
+#include "flags.h"
+#endif
+#include "timevar.h"
+
+/* See timevar.h for an explanation of timing variables. */
+
+/* This macro evaluates to non-zero if timing variables are enabled. */
+#define TIMEVAR_ENABLE (time_report)
+
+/* A timing variable. */
+
+struct timevar_def
+{
+ /* Elapsed time for this variable. */
+ struct timevar_time_def elapsed;
+
+ /* If this variable is timed independently of the timing stack,
+ using timevar_start, this contains the start time. */
+ struct timevar_time_def start_time;
+
+ /* The name of this timing variable. */
+ const char *name;
+
+ /* Non-zero if this timing variable is running as a standalone
+ timer. */
+ unsigned standalone : 1;
+
+ /* Non-zero if this timing variable was ever started or pushed onto
+ the timing stack. */
+ unsigned used : 1;
+};
+
+/* An element on the timing stack. Elapsed time is attributed to the
+ topmost timing variable on the stack. */
+
+struct timevar_stack_def
+{
+ /* The timing variable at this stack level. */
+ struct timevar_def *timevar;
+
+ /* The next lower timing variable context in the stack. */
+ struct timevar_stack_def *next;
+};
+
+/* Declared timing variables. Constructed from the contents of
+ timevar.def. */
+static struct timevar_def timevars[TIMEVAR_LAST];
+
+/* The top of the timing stack. */
+static struct timevar_stack_def *stack;
+
+/* A list of unused (i.e. allocated and subsequently popped)
+ timevar_stack_def instances. */
+static struct timevar_stack_def *unused_stack_instances;
+
+/* The time at which the topmost element on the timing stack was
+ pushed. Time elapsed since then is attributed to the topmost
+ element. */
+static struct timevar_time_def start_time;
+
+static void get_time
+ PARAMS ((struct timevar_time_def *));
+static void timevar_accumulate
+ PARAMS ((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. */
+
+static void
+get_time (now)
+ struct timevar_time_def *now;
+{
+ now->user = 0;
+ now->sys = 0;
+ now->wall = 0;
+
+ if (!TIMEVAR_ENABLE)
+ return;
+
+ {
+#ifdef USE_TIMES
+ struct tms tms;
+ now->wall = times (&tms) * ticks_to_msec;
+ now->user = tms.tms_utime * ticks_to_msec;
+ now->sys = tms.tms_stime * ticks_to_msec;
+#endif
+#ifdef USE_GETRUSAGE
+ struct rusage rusage;
+ getrusage (RUSAGE_SELF, &rusage);
+ now->user = rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec * 1e-6;
+ now->sys = rusage.ru_stime.tv_sec + rusage.ru_stime.tv_usec * 1e-6;
+#endif
+#ifdef USE_CLOCK
+ now->user = clock () * clocks_to_msec;
+#endif
+ }
+}
+
+/* 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;
+{
+ timer->user += stop_time->user - start_time->user;
+ timer->sys += stop_time->sys - start_time->sys;
+ timer->wall += stop_time->wall - start_time->wall;
+}
+
+/* Initialize timing variables. */
+
+void
+init_timevar ()
+{
+ if (!TIMEVAR_ENABLE)
+ return;
+
+ /* Zero all elapsed times. */
+ memset ((void *) timevars, 0, sizeof (timevars));
+
+ /* Initialize the names of timing variables. */
+#define DEFTIMEVAR(identifier__, name__) \
+ timevars[identifier__].name = name__;
+#include "timevar.def"
+#undef DEFTIMEVAR
+
+#ifdef USE_TIMES
+ ticks_to_msec = TICKS_TO_MSEC;
+#endif
+#ifdef USE_CLOCK
+ clocks_to_msec = CLOCKS_TO_MSEC;
+#endif
+}
+
+/* Push TIMEVAR onto the timing stack. No further elapsed time is
+ attributed to the previous topmost timing variable on the stack;
+ subsequent elapsed time is attributed to TIMEVAR, until it is
+ popped or another element is pushed on top.
+
+ TIMEVAR cannot be running as a standalone timer. */
+
+void
+timevar_push (timevar)
+ timevar_id_t timevar;
+{
+ struct timevar_def *tv = &timevars[timevar];
+ struct timevar_stack_def *context;
+ struct timevar_time_def now;
+
+ if (!TIMEVAR_ENABLE)
+ return;
+
+ /* Mark this timing variable as used. */
+ tv->used = 1;
+
+ /* Can't push a standalone timer. */
+ if (tv->standalone)
+ abort ();
+
+ /* What time is it? */
+ get_time (&now);
+
+ /* If the stack isn't empty, attribute the current elapsed time to
+ the old topmost element. */
+ if (stack)
+ timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
+
+ /* Reset the start time; from now on, time is attributed to
+ TIMEVAR. */
+ start_time = now;
+
+ /* See if we have a previously-allocated stack instance. If so,
+ take it off the list. If not, malloc a new one. */
+ if (unused_stack_instances != NULL)
+ {
+ context = unused_stack_instances;
+ unused_stack_instances = unused_stack_instances->next;
+ }
+ else
+ context = (struct timevar_stack_def *)
+ xmalloc (sizeof (struct timevar_stack_def));
+
+ /* Fill it in and put it on the stack. */
+ context->timevar = tv;
+ context->next = stack;
+ stack = context;
+}
+
+/* Pop the topmost timing variable element off the timing stack. The
+ popped variable must be TIMEVAR. Elapsed time since the that
+ element was pushed on, or since it was last exposed on top of the
+ stack when the element above it was popped off, is credited to that
+ timing variable. */
+
+void
+timevar_pop (timevar)
+ timevar_id_t timevar;
+{
+ struct timevar_time_def now;
+ struct timevar_stack_def *popped = stack;
+
+ if (!TIMEVAR_ENABLE)
+ return;
+
+ if (&timevars[timevar] != stack->timevar)
+ abort ();
+
+ /* What time is it? */
+ get_time (&now);
+
+ /* Attribute the elapsed time to the element we're popping. */
+ timevar_accumulate (&popped->timevar->elapsed, &start_time, &now);
+
+ /* Reset the start time; from now on, time is attributed to the
+ element just exposed on the stack. */
+ start_time = now;
+
+ /* Take the item off the stack. */
+ stack = stack->next;
+
+ /* Don't delete the stack element; instead, add it to the list of
+ unused elements for later use. */
+ popped->next = unused_stack_instances;
+ unused_stack_instances = popped;
+}
+
+/* Start timing TIMEVAR independently of the timing stack. Elapsed
+ time until timevar_stop is called for the same timing variable is
+ attributed to TIMEVAR. */
+
+void
+timevar_start (timevar)
+ 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 ();
+ tv->standalone = 1;
+
+ get_time (&tv->start_time);
+}
+
+/* Stop timing TIMEVAR. Time elapsed since timevar_start was called
+ is attributed to it. */
+
+void
+timevar_stop (timevar)
+ 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 ();
+
+ 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];
+ struct timevar_time_def now;
+
+ *elapsed = tv->elapsed;
+
+ /* Is TIMEVAR currently running as a standalone timer? */
+ if (tv->standalone)
+ {
+ get_time (&now);
+ timevar_accumulate (elapsed, &tv->start_time, &now);
+ }
+ /* Or is TIMEVAR at the top of the timer stack? */
+ else if (stack->timevar == tv)
+ {
+ get_time (&now);
+ timevar_accumulate (elapsed, &start_time, &now);
+ }
+}
+
+/* Summarize timing variables to FP. The timing variable TV_TOTAL has
+ a special meaning -- it's considered to be the total elapsed time,
+ for normalizing the others, and is displayed last. */
+
+void
+timevar_print (fp)
+ FILE *fp;
+{
+ /* Only print stuff if we have some sort of time information. */
+#if defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME) || defined (HAVE_WALL_TIME)
+ unsigned int /* timevar_id_t */ id;
+ struct timevar_time_def *total = &timevars[TV_TOTAL].elapsed;
+ struct timevar_time_def now;
+
+ if (!TIMEVAR_ENABLE)
+ return;
+
+ /* Update timing information in case we're calling this from GDB. */
+
+ if (fp == 0)
+ fp = stderr;
+
+ /* What time is it? */
+ get_time (&now);
+
+ /* If the stack isn't empty, attribute the current elapsed time to
+ the old topmost element. */
+ if (stack)
+ timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
+
+ /* Reset the start time; from now on, time is attributed to
+ TIMEVAR. */
+ start_time = now;
+
+ fputs (_("\nExecution times (seconds)\n"), fp);
+ for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id)
+ {
+ struct timevar_def *tv = &timevars[(timevar_id_t) id];
+ const float tiny = 5e-3;
+
+ /* Don't print the total execution time here; that goes at the
+ end. */
+ if ((timevar_id_t) id == TV_TOTAL)
+ continue;
+
+ /* Don't print timing variables that were never used. */
+ if (!tv->used)
+ continue;
+
+ /* Don't print timing variables if we're going to get a row of
+ zeroes. */
+ if (tv->elapsed.user < tiny
+ && tv->elapsed.sys < tiny
+ && tv->elapsed.wall < tiny)
+ continue;
+
+ /* The timing variable name. */
+ fprintf (fp, " %-22s:", tv->name);
+
+#ifdef HAVE_USER_TIME
+ /* Print user-mode time for this process. */
+ fprintf (fp, "%7.2f (%2.0f%%) usr",
+ tv->elapsed.user,
+ (total->user == 0 ? 0 : tv->elapsed.user / total->user) * 100);
+#endif /* HAVE_USER_TIME */
+
+#ifdef HAVE_SYS_TIME
+ /* Print system-mode time for this process. */
+ fprintf (fp, "%7.2f (%2.0f%%) sys",
+ tv->elapsed.sys,
+ (total->sys == 0 ? 0 : tv->elapsed.sys / total->sys) * 100);
+#endif /* HAVE_SYS_TIME */
+
+#ifdef HAVE_WALL_TIME
+ /* Print wall clock time elapsed. */
+ fprintf (fp, "%7.2f (%2.0f%%) wall",
+ tv->elapsed.wall,
+ (total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100);
+#endif /* HAVE_WALL_TIME */
+
+ putc ('\n', fp);
+ }
+
+ /* Print total time. */
+ fputs (_(" TOTAL :"), fp);
+#ifdef HAVE_USER_TIME
+ fprintf (fp, "%7.2f ", total->user);
+#endif
+#ifdef HAVE_SYS_TIME
+ fprintf (fp, "%7.2f ", total->sys);
+#endif
+#ifdef HAVE_WALL_TIME
+ fprintf (fp, "%7.2f\n", total->wall);
+#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. */
+
+long
+get_run_time ()
+{
+ struct timevar_time_def total_elapsed;
+ timevar_get (TV_TOTAL, &total_elapsed);
+ return total_elapsed.user + total_elapsed.sys;
+}
+
+/* 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;
+{
+ long all_time = get_run_time ();
+ fprintf (stderr,
+ _("time in %s: %ld.%06ld (%ld%%)\n"),
+ str, total / 1000000, total % 1000000,
+ all_time == 0 ? 0
+ : (long) (((100.0 * (double) total) / (double) all_time) + .5));
+}
--- /dev/null
+/* This file contains the definitions for timing variables used to -*- C -*-
+ measure run-time performance of the compiler.
+ Copyright (C) 2000 Free Software Foundation, Inc.
+ Contributed by Alex Samuel <samuel@codesourcery.com>
+
+ This file is part of GCC.
+
+ GCC is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ GCC is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GCC; see the file COPYING. If not, write to
+ the Free Software Foundation, 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+/* This file contains timing variable definitions, used by timevar.h
+ and timevar.c.
+
+ Syntax:
+
+ DEFTIMEVAR (id, name)
+
+ where ID is the enumeral value used to identify the timing
+ variable, and NAME is a character string describing its purpose. */
+
+/* The total execution time. */
+DEFTIMEVAR (TV_TOTAL , "total time")
+
+/* Time spent in the reader. */
+DEFTIMEVAR (TV_READER , "reader")
+DEFTIMEVAR (TV_SCANNING , "scanner")
+DEFTIMEVAR (TV_PARSING , "parser")
+
+/* Time spent handling the grammar. */
+DEFTIMEVAR (TV_REDUCE , "reducing the grammar")
+DEFTIMEVAR (TV_SETS , "computing the sets")
+DEFTIMEVAR (TV_LR0 , "LR(0)")
+DEFTIMEVAR (TV_LALR , "LALR(1)")
+DEFTIMEVAR (TV_CONFLICTS , "conflicts")
+
+/* Time spent outputing results. */
+DEFTIMEVAR (TV_REPORT , "outputing report")
+DEFTIMEVAR (TV_GRAPH , "outputing graph")
+DEFTIMEVAR (TV_ACTIONS , "parser action tables")
+DEFTIMEVAR (TV_PARSER , "outputing parser")
+DEFTIMEVAR (TV_M4 , "running m4")
+
+/* Time spent by freeing the memory :). */
+DEFTIMEVAR (TV_FREE , "freeing")
--- /dev/null
+/* Timing variables for measuring compiler performance.
+ Copyright (C) 2000 Free Software Foundation, Inc.
+ Contributed by Alex Samuel <samuel@codesourcery.com>
+
+ This file is part of GCC.
+
+ GCC is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ GCC is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+ License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GCC; see the file COPYING. If not, write to the Free
+ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA. */
+
+#ifndef GCC_TIMEVAR_H
+#define GCC_TIMEVAR_H
+
+/* Timing variables are used to measure elapsed time in various
+ portions of the compiler. Each measures elapsed user, system, and
+ wall-clock time, as appropriate to and supported by the host
+ system.
+
+ Timing variables are defined using the DEFTIMEVAR macro in
+ timevar.def. Each has an enumeral identifier, used when referring
+ to the timing variable in code, and a character string name.
+
+ Timing variables can be used in two ways:
+
+ - On the timing stack, using timevar_push and timevar_pop.
+ Timing variables may be pushed onto the stack; elapsed time is
+ attributed to the topmost timing variable on the stack. When
+ another variable is pushed on, the previous topmost variable is
+ `paused' until the pushed variable is popped back off.
+
+ - As a standalone timer, using timevar_start and timevar_stop.
+ All time elapsed between the two calls is attributed to the
+ variable.
+*/
+
+/* This structure stores the various varieties of time that can be
+ measured. Times are stored in seconds. The time may be an
+ absolute time or a time difference; in the former case, the time
+ base is undefined, except that the difference between two times
+ produces a valid time difference. */
+
+struct timevar_time_def
+{
+ /* User time in this process. */
+ float user;
+
+ /* System time (if applicable for this host platform) in this
+ process. */
+ float sys;
+
+ /* Wall clock time. */
+ float wall;
+};
+
+/* An enumeration of timing variable identifiers. Constructed from
+ the contents of timevar.def. */
+
+#define DEFTIMEVAR(identifier__, name__) \
+ identifier__,
+typedef enum
+{
+#include "timevar.def"
+ TIMEVAR_LAST
+}
+timevar_id_t;
+#undef DEFTIMEVAR
+
+extern void init_timevar PARAMS ((void));
+extern void timevar_push PARAMS ((timevar_id_t));
+extern void timevar_pop PARAMS ((timevar_id_t));
+extern void timevar_start PARAMS ((timevar_id_t));
+extern void timevar_stop PARAMS ((timevar_id_t));
+extern void timevar_get PARAMS ((timevar_id_t, struct timevar_time_def *));
+extern void timevar_print PARAMS ((FILE *));
+
+/* Provided for backward compatibility. */
+extern long get_run_time PARAMS ((void));
+extern void print_time PARAMS ((const char *, long));
+
+#endif /* ! GCC_TIMEVAR_H */
realloc.m4 \
stage.m4 \
strerror_r.m4 \
+timevar.m4 \
warning.m4
# serial 1
AC_DEFUN([BISON_PREREQ_STAGE],
-[AC_CHECK_HEADERS([malloc.h sys/times.h])
-AC_CHECK_FUNCS([mallinfo times])
+[AC_CHECK_HEADERS([malloc.h])
+AC_CHECK_FUNCS([mallinfo])
AC_CHECK_TYPES([struct mallinfo], [], [],
[$ac_includes_default
# include <malloc.h>
#endif
])
-
-AC_CHECK_TYPES([struct tms], [], [],
-[$ac_includes_default
-#if HAVE_SYS_TIMES_H
-# include <sys/times.h>
-#endif
-])
])
--- /dev/null
+# -*-Autoconf-*-
+# Checks required to run `stage', a nonportable memory/time tracker.
+#
+# Copyright (C) 2002 Free Software Foundation, Inc.
+#
+# This program 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 of the License, or
+# (at your option) any later version.
+#
+# This program 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 this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+# 02111-1307 USA
+
+# serial 1
+
+AC_DEFUN([BISON_PREREQ_TIMEVAR],
+[AC_CHECK_HEADERS([sys/resource.h sys/times.h])
+
+AC_CHECK_FUNCS([times])
+
+AC_CHECK_DECLS([getrusage, times, clock, sysconf], [], [],
+[$ac_includes_default
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#endif
+#if HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif
+])
+
+AC_CHECK_TYPES([clock_t, struct tms], [], [],
+[$ac_includes_default
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
+#endif
+#if HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif
+])
+])
"automaton - contruction of the automaton",
"bitsets - use of bitsets",
"grammar - reading, reducing of the grammar",
- "resource - time and memory (where available)",
+ "resource - memory consumption (where available)",
"sets - grammar sets: firsts, nullable etc.",
+ "time - time consumption",
"tools - m4 invocation and preserve the temporary file",
"all - all of the above",
0
trace_grammar,
trace_resource,
trace_sets,
+ trace_time,
trace_tools,
trace_all
};
trace_tools = 1 << 3,
trace_automaton = 1 << 4,
trace_grammar = 1 << 5,
+ trace_time = 1 << 6,
trace_all = ~0
};
extern int trace_flag;
char *program_name;
-/*--------------------------.
-| Tracking space and time. |
-`--------------------------*/
-
-static void
-stage (const char *title)
-{
-#if HAVE_MALLINFO && HAVE_STRUCT_MALLINFO & HAVE_TIMES & HAVE_STRUCT_TMS
- if (trace_flag & trace_resource)
- {
- struct mallinfo minfo = mallinfo ();
- struct tms tinfo;
- times (&tinfo);
- fprintf (stderr, "STAGE: %30s: %9d (%9d): %ldu %lds\n",
- title,
- minfo.uordblks, minfo.arena,
- tinfo.tms_utime, tinfo.tms_stime);
- }
-#endif
-}
-
int
main (int argc, char *argv[])
getargs (argc, argv);
+ time_report = trace_flag & trace_time;
+ init_timevar ();
+ timevar_start (TV_TOTAL);
+
if (trace_flag & trace_bitsets)
bitset_stats_enable ();
muscle_init ();
- stage ("initialized muscles");
-
/* Read the input. Copy some parts of it to FGUARD, FACTION, FTABLE
and FATTRS. In file reader.c. The other parts are recorded in
the grammar; see gram.h. */
- reader ();
- stage ("reader");
+ timevar_push (TV_READER);
+ reader ();
+ timevar_pop (TV_READER);
if (complain_message_count)
exit (1);
/* Find useless nonterminals and productions and reduce the grammar. */
+ timevar_push (TV_REDUCE);
reduce_grammar ();
-
- stage ("reduced grammar");
+ timevar_pop (TV_REDUCE);
/* Record other info about the grammar. In files derives and
nullable. */
+ timevar_push (TV_SETS);
set_derives ();
set_nullable ();
+ timevar_pop (TV_SETS);
/* Convert to nondeterministic finite state machine. In file LR0.
See state.h for more info. */
+ timevar_push (TV_LR0);
generate_states ();
+ timevar_pop (TV_LR0);
- stage ("generated states");
/* make it deterministic. In file lalr. */
+ timevar_push (TV_LALR);
lalr ();
+ timevar_pop (TV_LALR);
- stage ("lalred");
/* Find and record any conflicts: places where one token of
lookahead is not enough to disambiguate the parsing. In file
conflicts. Also resolve s/r conflicts based on precedence
declarations. */
+ timevar_push (TV_CONFLICTS);
conflicts_solve ();
conflicts_print ();
+ timevar_pop (TV_CONFLICTS);
- stage ("solved conflicts");
/* Output file names. */
compute_output_file_names ();
/* Output the detailed report on the grammar. */
if (report_flag)
- print_results ();
+ {
+ timevar_push (TV_REPORT);
+ print_results ();
+ timevar_pop (TV_REPORT);
+ }
- stage ("printed results");
/* Stop if there were errors, to avoid trashing previous output
files. */
if (complain_message_count)
/* Output the VCG graph. */
if (graph_flag)
- print_graph ();
+ {
+ timevar_push (TV_GRAPH);
+ print_graph ();
+ timevar_pop (TV_GRAPH);
+ }
/* Output the tables and the parser to ftable. In file output. */
+ timevar_push (TV_PARSER);
output ();
- stage ("made output");
+ timevar_pop (TV_PARSER);
+ timevar_push (TV_FREE);
states_free ();
- stage ("freed states");
reduce_free ();
- stage ("freed reduce");
conflicts_free ();
- stage ("freed conflicts");
free_nullable ();
- stage ("freed nullable");
free_derives ();
- stage ("freed derives");
grammar_free ();
- stage ("freed grammar");
/* The scanner memory cannot be released right after parsing, as it
contains things such as user actions, prologue, epilogue etc. */
scanner_free ();
- stage ("freed scanner");
muscle_free ();
- stage ("freed muscles");
/* If using alloca.c, flush the alloca'ed memory for the benefit of
people running Bison as a library in IDEs. */
#if C_ALLOCA
alloca (0);
#endif
+ timevar_pop (TV_FREE);
if (trace_flag & trace_bitsets)
bitset_stats_dump (stderr);
+ /* Stop timing and print the times. */
+ timevar_stop (TV_TOTAL);
+ timevar_print (stderr);
+
return complain_message_count ? EXIT_FAILURE : EXIT_SUCCESS;
}
XFREE (check);
}
+
/*-----------------------------------------------------------------.
| Compute and output yydefact, yydefgoto, yypact, yypgoto, yytable |
| and yycheck. |
fputs ("m4_divert_push(0)dnl\n", out);
xfclose (out);
+ timevar_push (TV_M4);
m4_invoke (tempfile);
+ timevar_pop (TV_M4);
/* If `debugging', keep this file alive. */
if (!(trace_flag & trace_tools))
prepare_tokens ();
prepare_rules ();
prepare_states ();
+ timevar_push (TV_ACTIONS);
prepare_actions ();
+ timevar_pop (TV_ACTIONS);
prepare ();
#endif
-/* Find `times' where available. */
-#if HAVE_SYS_TIMES_H
-# include <sys/times.h>
-#endif
+/*----------------.
+| Using timevar. |
+`----------------*/
+
+#include "timevar.h"
+extern int time_report;
/*---------------------.
projects / bison.git / commitdiff
