1/* Timing variables for measuring compiler performance.
2
3   Copyright (C) 2000, 2002, 2004, 2006, 2009-2012 Free Software
4   Foundation, Inc.
5
6   Contributed by Alex Samuel <samuel@codesourcery.com>
7
8   This program is free software: you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation, either version 3 of the License, or
11   (at your option) any later version.
12
13   This program is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21#include <config.h>
22
23#if IN_GCC
24
25#include "system.h"
26#include "intl.h"
27#include "rtl.h"
28
29#else
30
31/* This source file is taken from the GCC source code, with slight
32   modifications that are under control of the IN_GCC preprocessor
33   variable.  The !IN_GCC part of this file is specific to Bison.  */
34
35# include "../src/system.h"
36# if HAVE_SYS_TIME_H
37#  include <sys/time.h>
38# endif
39int timevar_report = 0;
40
41#endif
42
43
44#ifdef HAVE_SYS_TIMES_H
45# include <sys/times.h>
46#endif
47#ifdef HAVE_SYS_RESOURCE_H
48#include <sys/resource.h>
49#endif
50
51#ifndef HAVE_CLOCK_T
52typedef int clock_t;
53#endif
54
55#ifndef HAVE_STRUCT_TMS
56struct tms
57{
58  clock_t tms_utime;
59  clock_t tms_stime;
60  clock_t tms_cutime;
61  clock_t tms_cstime;
62};
63#endif
64
65#if defined HAVE_DECL_GETRUSAGE && !HAVE_DECL_GETRUSAGE
66extern int getrusage (int, struct rusage *);
67#endif
68#if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES
69extern clock_t times (struct tms *);
70#endif
71#if defined HAVE_DECL_CLOCK && !HAVE_DECL_CLOCK
72extern clock_t clock (void);
73#endif
74
75#ifndef RUSAGE_SELF
76# define RUSAGE_SELF 0
77#endif
78
79/* Calculation of scale factor to convert ticks to microseconds.
80   We mustn't use CLOCKS_PER_SEC except with clock().  */
81#if HAVE_SYSCONF && defined _SC_CLK_TCK
82# define TICKS_PER_SECOND sysconf (_SC_CLK_TCK) /* POSIX 1003.1-1996 */
83#else
84# ifdef CLK_TCK
85#  define TICKS_PER_SECOND CLK_TCK /* POSIX 1003.1-1988; obsolescent */
86# else
87#  ifdef HZ
88#   define TICKS_PER_SECOND HZ  /* traditional UNIX */
89#  else
90#   define TICKS_PER_SECOND 100 /* often the correct value */
91#  endif
92# endif
93#endif
94
95/* Prefer times to getrusage to clock (each gives successively less
96   information).  */
97#ifdef HAVE_TIMES
98# define USE_TIMES
99# define HAVE_USER_TIME
100# define HAVE_SYS_TIME
101# define HAVE_WALL_TIME
102#else
103#ifdef HAVE_GETRUSAGE
104# define USE_GETRUSAGE
105# define HAVE_USER_TIME
106# define HAVE_SYS_TIME
107#else
108#ifdef HAVE_CLOCK
109# define USE_CLOCK
110# define HAVE_USER_TIME
111#endif
112#endif
113#endif
114
115/* libc is very likely to have snuck a call to sysconf() into one of
116   the underlying constants, and that can be very slow, so we have to
117   precompute them.  Whose wonderful idea was it to make all those
118   _constants_ variable at run time, anyway?  */
119#ifdef USE_TIMES
120static float ticks_to_msec;
121#define TICKS_TO_MSEC (1.0 / TICKS_PER_SECOND)
122#endif
123
124#ifdef USE_CLOCK
125static float clocks_to_msec;
126#define CLOCKS_TO_MSEC (1.0 / CLOCKS_PER_SEC)
127#endif
128
129#if IN_GCC
130#include "flags.h"
131#endif
132#include "timevar.h"
133
134/* See timevar.h for an explanation of timing variables.  */
135
136/* This macro evaluates to nonzero if timing variables are enabled.  */
137#define TIMEVAR_ENABLE (timevar_report)
138
139/* A timing variable.  */
140
141struct timevar_def
142{
143  /* Elapsed time for this variable.  */
144  struct timevar_time_def elapsed;
145
146  /* If this variable is timed independently of the timing stack,
147     using timevar_start, this contains the start time.  */
148  struct timevar_time_def start_time;
149
150  /* The name of this timing variable.  */
151  const char *name;
152
153  /* Non-zero if this timing variable is running as a standalone
154     timer.  */
155  unsigned standalone : 1;
156
157  /* Non-zero if this timing variable was ever started or pushed onto
158     the timing stack.  */
159  unsigned used : 1;
160};
161
162/* An element on the timing stack.  Elapsed time is attributed to the
163   topmost timing variable on the stack.  */
164
165struct timevar_stack_def
166{
167  /* The timing variable at this stack level.  */
168  struct timevar_def *timevar;
169
170  /* The next lower timing variable context in the stack.  */
171  struct timevar_stack_def *next;
172};
173
174/* Declared timing variables.  Constructed from the contents of
175   timevar.def.  */
176static struct timevar_def timevars[TIMEVAR_LAST];
177
178/* The top of the timing stack.  */
179static struct timevar_stack_def *stack;
180
181/* A list of unused (i.e. allocated and subsequently popped)
182   timevar_stack_def instances.  */
183static struct timevar_stack_def *unused_stack_instances;
184
185/* The time at which the topmost element on the timing stack was
186   pushed.  Time elapsed since then is attributed to the topmost
187   element.  */
188static struct timevar_time_def start_time;
189
190static void get_time (struct timevar_time_def *);
191static void timevar_accumulate (struct timevar_time_def *,
192				struct timevar_time_def *,
193				struct timevar_time_def *);
194
195/* Fill the current times into TIME.  The definition of this function
196   also defines any or all of the HAVE_USER_TIME, HAVE_SYS_TIME, and
197   HAVE_WALL_TIME macros.  */
198
199static void
200get_time (now)
201     struct timevar_time_def *now;
202{
203  now->user = 0;
204  now->sys  = 0;
205  now->wall = 0;
206
207  if (!TIMEVAR_ENABLE)
208    return;
209
210  {
211#ifdef USE_TIMES
212    struct tms tms;
213    now->wall = times (&tms)  * ticks_to_msec;
214#if IN_GCC
215    now->user = tms.tms_utime * ticks_to_msec;
216    now->sys  = tms.tms_stime * ticks_to_msec;
217#else
218    now->user = (tms.tms_utime + tms.tms_cutime) * ticks_to_msec;
219    now->sys  = (tms.tms_stime + tms.tms_cstime) * ticks_to_msec;
220#endif
221#endif
222#ifdef USE_GETRUSAGE
223    struct rusage rusage;
224#if IN_GCC
225    getrusage (RUSAGE_SELF, &rusage);
226#else
227    getrusage (RUSAGE_CHILDREN, &rusage);
228#endif
229    now->user = rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec * 1e-6;
230    now->sys  = rusage.ru_stime.tv_sec + rusage.ru_stime.tv_usec * 1e-6;
231#endif
232#ifdef USE_CLOCK
233    now->user = clock () * clocks_to_msec;
234#endif
235  }
236}
237
238/* Add the difference between STOP and START to TIMER.  */
239
240static void
241timevar_accumulate (timer, start, stop)
242     struct timevar_time_def *timer;
243     struct timevar_time_def *start;
244     struct timevar_time_def *stop;
245{
246  timer->user += stop->user - start->user;
247  timer->sys += stop->sys - start->sys;
248  timer->wall += stop->wall - start->wall;
249}
250
251/* Initialize timing variables.  */
252
253void
254init_timevar ()
255{
256  if (!TIMEVAR_ENABLE)
257    return;
258
259  /* Zero all elapsed times.  */
260  memset ((void *) timevars, 0, sizeof (timevars));
261
262  /* Initialize the names of timing variables.  */
263#define DEFTIMEVAR(identifier__, name__) \
264  timevars[identifier__].name = name__;
265#include "timevar.def"
266#undef DEFTIMEVAR
267
268#ifdef USE_TIMES
269  ticks_to_msec = TICKS_TO_MSEC;
270#endif
271#ifdef USE_CLOCK
272  clocks_to_msec = CLOCKS_TO_MSEC;
273#endif
274}
275
276/* Push TIMEVAR onto the timing stack.  No further elapsed time is
277   attributed to the previous topmost timing variable on the stack;
278   subsequent elapsed time is attributed to TIMEVAR, until it is
279   popped or another element is pushed on top.
280
281   TIMEVAR cannot be running as a standalone timer.  */
282
283void
284timevar_push (timevar)
285     timevar_id_t timevar;
286{
287  struct timevar_def *tv = &timevars[timevar];
288  struct timevar_stack_def *context;
289  struct timevar_time_def now;
290
291  if (!TIMEVAR_ENABLE)
292    return;
293
294  /* Mark this timing variable as used.  */
295  tv->used = 1;
296
297  /* Can't push a standalone timer.  */
298  if (tv->standalone)
299    abort ();
300
301  /* What time is it?  */
302  get_time (&now);
303
304  /* If the stack isn't empty, attribute the current elapsed time to
305     the old topmost element.  */
306  if (stack)
307    timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
308
309  /* Reset the start time; from now on, time is attributed to
310     TIMEVAR.  */
311  start_time = now;
312
313  /* See if we have a previously-allocated stack instance.  If so,
314     take it off the list.  If not, malloc a new one.  */
315  if (unused_stack_instances != NULL)
316    {
317      context = unused_stack_instances;
318      unused_stack_instances = unused_stack_instances->next;
319    }
320  else
321    context = (struct timevar_stack_def *)
322      xmalloc (sizeof (struct timevar_stack_def));
323
324  /* Fill it in and put it on the stack.  */
325  context->timevar = tv;
326  context->next = stack;
327  stack = context;
328}
329
330/* Pop the topmost timing variable element off the timing stack.  The
331   popped variable must be TIMEVAR.  Elapsed time since the that
332   element was pushed on, or since it was last exposed on top of the
333   stack when the element above it was popped off, is credited to that
334   timing variable.  */
335
336void
337timevar_pop (timevar)
338     timevar_id_t timevar;
339{
340  struct timevar_time_def now;
341  struct timevar_stack_def *popped = stack;
342
343  if (!TIMEVAR_ENABLE)
344    return;
345
346  if (&timevars[timevar] != stack->timevar)
347    abort ();
348
349  /* What time is it?  */
350  get_time (&now);
351
352  /* Attribute the elapsed time to the element we're popping.  */
353  timevar_accumulate (&popped->timevar->elapsed, &start_time, &now);
354
355  /* Reset the start time; from now on, time is attributed to the
356     element just exposed on the stack.  */
357  start_time = now;
358
359  /* Take the item off the stack.  */
360  stack = stack->next;
361
362  /* Don't delete the stack element; instead, add it to the list of
363     unused elements for later use.  */
364  popped->next = unused_stack_instances;
365  unused_stack_instances = popped;
366}
367
368/* Start timing TIMEVAR independently of the timing stack.  Elapsed
369   time until timevar_stop is called for the same timing variable is
370   attributed to TIMEVAR.  */
371
372void
373timevar_start (timevar)
374     timevar_id_t timevar;
375{
376  struct timevar_def *tv = &timevars[timevar];
377
378  if (!TIMEVAR_ENABLE)
379    return;
380
381  /* Mark this timing variable as used.  */
382  tv->used = 1;
383
384  /* Don't allow the same timing variable to be started more than
385     once.  */
386  if (tv->standalone)
387    abort ();
388  tv->standalone = 1;
389
390  get_time (&tv->start_time);
391}
392
393/* Stop timing TIMEVAR.  Time elapsed since timevar_start was called
394   is attributed to it.  */
395
396void
397timevar_stop (timevar)
398     timevar_id_t timevar;
399{
400  struct timevar_def *tv = &timevars[timevar];
401  struct timevar_time_def now;
402
403  if (!TIMEVAR_ENABLE)
404    return;
405
406  /* TIMEVAR must have been started via timevar_start.  */
407  if (!tv->standalone)
408    abort ();
409
410  get_time (&now);
411  timevar_accumulate (&tv->elapsed, &tv->start_time, &now);
412}
413
414/* Fill the elapsed time for TIMEVAR into ELAPSED.  Returns
415   update-to-date information even if TIMEVAR is currently running.  */
416
417void
418timevar_get (timevar, elapsed)
419     timevar_id_t timevar;
420     struct timevar_time_def *elapsed;
421{
422  struct timevar_def *tv = &timevars[timevar];
423  struct timevar_time_def now;
424
425  *elapsed = tv->elapsed;
426
427  /* Is TIMEVAR currently running as a standalone timer?  */
428  if (tv->standalone)
429    {
430      get_time (&now);
431      timevar_accumulate (elapsed, &tv->start_time, &now);
432    }
433  /* Or is TIMEVAR at the top of the timer stack?  */
434  else if (stack->timevar == tv)
435    {
436      get_time (&now);
437      timevar_accumulate (elapsed, &start_time, &now);
438    }
439}
440
441/* Summarize timing variables to FP.  The timing variable TV_TOTAL has
442   a special meaning -- it's considered to be the total elapsed time,
443   for normalizing the others, and is displayed last.  */
444
445void
446timevar_print (fp)
447     FILE *fp;
448{
449  /* Only print stuff if we have some sort of time information.  */
450#if defined HAVE_USER_TIME || defined HAVE_SYS_TIME || defined HAVE_WALL_TIME
451  unsigned int /* timevar_id_t */ id;
452  struct timevar_time_def *total = &timevars[TV_TOTAL].elapsed;
453  struct timevar_time_def now;
454
455  if (!TIMEVAR_ENABLE)
456    return;
457
458  /* Update timing information in case we're calling this from GDB.  */
459
460  if (fp == 0)
461    fp = stderr;
462
463  /* What time is it?  */
464  get_time (&now);
465
466  /* If the stack isn't empty, attribute the current elapsed time to
467     the old topmost element.  */
468  if (stack)
469    timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
470
471  /* Reset the start time; from now on, time is attributed to
472     TIMEVAR.  */
473  start_time = now;
474
475  fputs (_("\nExecution times (seconds)\n"), fp);
476  for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id)
477    {
478      struct timevar_def *tv = &timevars[(timevar_id_t) id];
479      const float tiny = 5e-3;
480
481      /* Don't print the total execution time here; that goes at the
482	 end.  */
483      if ((timevar_id_t) id == TV_TOTAL)
484	continue;
485
486      /* Don't print timing variables that were never used.  */
487      if (!tv->used)
488	continue;
489
490      /* Don't print timing variables if we're going to get a row of
491	 zeroes.  */
492      if (tv->elapsed.user < tiny
493	  && tv->elapsed.sys < tiny
494	  && tv->elapsed.wall < tiny)
495	continue;
496
497      /* The timing variable name.  */
498      fprintf (fp, " %-22s:", tv->name);
499
500#ifdef HAVE_USER_TIME
501      /* Print user-mode time for this process.  */
502      fprintf (fp, "%7.2f (%2.0f%%) usr",
503	       tv->elapsed.user,
504	       (total->user == 0 ? 0 : tv->elapsed.user / total->user) * 100);
505#endif /* HAVE_USER_TIME */
506
507#ifdef HAVE_SYS_TIME
508      /* Print system-mode time for this process.  */
509      fprintf (fp, "%7.2f (%2.0f%%) sys",
510	       tv->elapsed.sys,
511	       (total->sys == 0 ? 0 : tv->elapsed.sys / total->sys) * 100);
512#endif /* HAVE_SYS_TIME */
513
514#ifdef HAVE_WALL_TIME
515      /* Print wall clock time elapsed.  */
516      fprintf (fp, "%7.2f (%2.0f%%) wall",
517	       tv->elapsed.wall,
518	       (total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100);
519#endif /* HAVE_WALL_TIME */
520
521      putc ('\n', fp);
522    }
523
524  /* Print total time.  */
525  fputs (_(" TOTAL                 :"), fp);
526#ifdef HAVE_USER_TIME
527  fprintf (fp, "%7.2f          ", total->user);
528#endif
529#ifdef HAVE_SYS_TIME
530  fprintf (fp, "%7.2f          ", total->sys);
531#endif
532#ifdef HAVE_WALL_TIME
533  fprintf (fp, "%7.2f\n", total->wall);
534#endif
535
536#endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
537	  || defined (HAVE_WALL_TIME) */
538}
539
540/* Returns time (user + system) used so far by the compiler process,
541   in microseconds.  */
542
543long
544get_run_time ()
545{
546  struct timevar_time_def total_elapsed;
547  timevar_get (TV_TOTAL, &total_elapsed);
548  return total_elapsed.user + total_elapsed.sys;
549}
550
551/* Prints a message to stderr stating that time elapsed in STR is
552   TOTAL (given in microseconds).  */
553
554void
555print_time (str, total)
556     const char *str;
557     long total;
558{
559  long all_time = get_run_time ();
560  fprintf (stderr,
561	   _("time in %s: %ld.%06ld (%ld%%)\n"),
562	   str, total / 1000000, total % 1000000,
563	   all_time == 0 ? 0
564	   : (long) (((100.0 * (double) total) / (double) all_time) + .5));
565}
566