lib/timevar.c

   1 /* Timing variables for measuring compiler performance.
   2
   3    Copyright (C) 2000, 2002, 2004, 2006, 2009-2013 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
  39 int 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
  52 typedef int clock_t;
  53 #endif
  54
  55 #ifndef HAVE_STRUCT_TMS
  56 struct 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
  66 extern int getrusage (int, struct rusage *);
  67 #endif
  68 #if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES
  69 extern clock_t times (struct tms *);
  70 #endif
  71 #if defined HAVE_DECL_CLOCK && !HAVE_DECL_CLOCK
  72 extern 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
 120 static float ticks_to_msec;
 121 #define TICKS_TO_MSEC (1.0 / TICKS_PER_SECOND)
 122 #endif
 123
 124 #ifdef USE_CLOCK
 125 static 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
 141 struct 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
 165 struct 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.  */
 176 static struct timevar_def timevars[TIMEVAR_LAST];
 177
 178 /* The top of the timing stack.  */
 179 static struct timevar_stack_def *stack;
 180
 181 /* A list of unused (i.e. allocated and subsequently popped)
 182    timevar_stack_def instances.  */
 183 static 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.  */
 188 static struct timevar_time_def start_time;
 189
 190 static void get_time (struct timevar_time_def *);
 191 static 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
 199 static void
 200 get_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
 240 static void
 241 timevar_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
 253 void
 254 init_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
 283 void
 284 timevar_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
 336 void
 337 timevar_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
 372 void
 373 timevar_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
 396 void
 397 timevar_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
 417 void
 418 timevar_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
 445 void
 446 timevar_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
 543 long
 544 get_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
 554 void
 555 print_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 }