diff options
| -rw-r--r-- | ChangeLog | 16 | ||||
| -rw-r--r-- | configure.in | 1 | ||||
| -rw-r--r-- | lib/Makefile.am | 4 | ||||
| -rw-r--r-- | lib/timevar.c | 553 | ||||
| -rw-r--r-- | lib/timevar.def | 56 | ||||
| -rw-r--r-- | lib/timevar.h | 91 | ||||
| -rw-r--r-- | m4/Makefile.am | 1 | ||||
| -rw-r--r-- | m4/stage.m4 | 11 | ||||
| -rw-r--r-- | m4/timevar.m4 | 47 | ||||
| -rw-r--r-- | src/getargs.c | 4 | ||||
| -rw-r--r-- | src/getargs.h | 1 | ||||
| -rw-r--r-- | src/main.c | 77 | ||||
| -rw-r--r-- | src/output.c | 5 | ||||
| -rw-r--r-- | src/system.h | 10 |
14 files changed, 821 insertions, 56 deletions
@@ -1,5 +1,21 @@ 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. * src/getargs.h (enum trace_e): New. diff --git a/configure.in b/configure.in index 85ae8615..adb71291 100644 --- a/configure.in +++ b/configure.in @@ -100,6 +100,7 @@ jm_FUNC_REALLOC jm_PREREQ_QUOTEARG jm_PREREQ_ERROR AM_WITH_DMALLOC +BISON_PREREQ_TIMEVAR BISON_PREREQ_STAGE # Gettext. diff --git a/lib/Makefile.am b/lib/Makefile.am index d867394a..d2b8350d 100644 --- a/lib/Makefile.am +++ b/lib/Makefile.am @@ -55,5 +55,9 @@ bbitset.h bitset_stats.c bitsetv.h lbitset.c 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) diff --git a/lib/timevar.c b/lib/timevar.c new file mode 100644 index 00000000..3cc38389 --- /dev/null +++ b/lib/timevar.c @@ -0,0 +1,553 @@ +/* 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)); +} diff --git a/lib/timevar.def b/lib/timevar.def new file mode 100644 index 00000000..a82666b3 --- /dev/null +++ b/lib/timevar.def @@ -0,0 +1,56 @@ +/* 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") diff --git a/lib/timevar.h b/lib/timevar.h new file mode 100644 index 00000000..f0d2fd2a --- /dev/null +++ b/lib/timevar.h @@ -0,0 +1,91 @@ +/* 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 */ diff --git a/m4/Makefile.am b/m4/Makefile.am index e2318d60..41941c92 100644 --- a/m4/Makefile.am +++ b/m4/Makefile.am @@ -19,4 +19,5 @@ progtest.m4 \ realloc.m4 \ stage.m4 \ strerror_r.m4 \ +timevar.m4 \ warning.m4 diff --git a/m4/stage.m4 b/m4/stage.m4 index 6f85a5ac..d28ad5e7 100644 --- a/m4/stage.m4 +++ b/m4/stage.m4 @@ -21,8 +21,8 @@ # 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 @@ -30,11 +30,4 @@ AC_CHECK_TYPES([struct mallinfo], [], [], # include <malloc.h> #endif ]) - -AC_CHECK_TYPES([struct tms], [], [], -[$ac_includes_default -#if HAVE_SYS_TIMES_H -# include <sys/times.h> -#endif -]) ]) diff --git a/m4/timevar.m4 b/m4/timevar.m4 new file mode 100644 index 00000000..fe078990 --- /dev/null +++ b/m4/timevar.m4 @@ -0,0 +1,47 @@ +# -*-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 +]) +]) diff --git a/src/getargs.c b/src/getargs.c index bc490a85..9f6aef4a 100644 --- a/src/getargs.c +++ b/src/getargs.c @@ -55,8 +55,9 @@ static const char * const trace_args[] = "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 @@ -70,6 +71,7 @@ static const int trace_types[] = trace_grammar, trace_resource, trace_sets, + trace_time, trace_tools, trace_all }; diff --git a/src/getargs.h b/src/getargs.h index a93fd55f..adf95123 100644 --- a/src/getargs.h +++ b/src/getargs.h @@ -45,6 +45,7 @@ enum trace_e trace_tools = 1 << 3, trace_automaton = 1 << 4, trace_grammar = 1 << 5, + trace_time = 1 << 6, trace_all = ~0 }; extern int trace_flag; @@ -44,27 +44,6 @@ 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[]) @@ -76,58 +55,69 @@ 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) @@ -135,39 +125,42 @@ main (int argc, char *argv[]) /* 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; } diff --git a/src/output.c b/src/output.c index 07977a5d..9626bdeb 100644 --- a/src/output.c +++ b/src/output.c @@ -1289,6 +1289,7 @@ output_check (void) XFREE (check); } + /*-----------------------------------------------------------------. | Compute and output yydefact, yydefgoto, yypact, yypgoto, yytable | | and yycheck. | @@ -1378,7 +1379,9 @@ output_skeleton (void) 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)) @@ -1451,7 +1454,9 @@ output (void) prepare_tokens (); prepare_rules (); prepare_states (); + timevar_push (TV_ACTIONS); prepare_actions (); + timevar_pop (TV_ACTIONS); prepare (); diff --git a/src/system.h b/src/system.h index 6250122a..68e62802 100644 --- a/src/system.h +++ b/src/system.h @@ -110,10 +110,12 @@ char *xstrndup PARAMS ((const char *s, size_t n)); #endif -/* Find `times' where available. */ -#if HAVE_SYS_TIMES_H -# include <sys/times.h> -#endif +/*----------------. +| Using timevar. | +`----------------*/ + +#include "timevar.h" +extern int time_report; /*---------------------. |