gprofng/testsuite/gprofng.display/synprog/stopwatch.c

   1 /* Copyright (C) 2021-2024 Free Software Foundation, Inc.
   2    Contributed by Oracle.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29
  30 #include "stopwatch.h"
  31
  32 static char *prhrdelta (hrtime_t);
  33 static char *prhrvdelta (hrtime_t);
  34 void init_micro_acct ();
  35
  36 /* stopwatch routines */
  37 void
  38 stpwtch_calibrate ()
  39 {
  40   struct timeval ttime;
  41   char buf[1024];
  42
  43   (void) gettimeofday (&ttime, NULL);
  44   time_t secs = (time_t) ttime.tv_sec;
  45   sprintf (buf, "%s Stopwatch calibration", prtime (&secs));
  46   wlog (buf, NULL);
  47
  48   init_micro_acct ();
  49   stopwatch_t *inner = stpwtch_alloc ("inner", 0);
  50   stopwatch_t *outer = stpwtch_alloc ("outer", 0);
  51   for (int i = 0; i < 1000; i++)
  52     {
  53       stpwtch_start (outer);
  54       stpwtch_start (inner);
  55       stpwtch_stop (inner);
  56       stpwtch_stop (outer);
  57     }
  58   stpwtch_print (inner);
  59   stpwtch_print (outer);
  60   free ((void *) inner);
  61   free ((void *) outer);
  62 }
  63
  64 stopwatch_t *
  65 stpwtch_alloc (char *name, int histo)
  66 {
  67   stopwatch_t *w = (stopwatch_t *) malloc (sizeof (stopwatch_t));
  68   if (w == NULL)
  69     {
  70       fprintf (stderr, "stpwtch_alloc(%s, %d): malloc failed\n", name, histo);
  71       return NULL;
  72     }
  73   w->sum = 0.;
  74   w->sumsq = 0.;
  75   w->count = 0;
  76   w->min = 0;
  77   w->last = 0;
  78   w->name = strdup (name);
  79   stpwtch_start (w);
  80   w->begin = w->start;
  81
  82   return w;
  83 }
  84
  85 void
  86 stpwtch_start (stopwatch_t *w)
  87 {
  88   w->start = gethrtime ();
  89 }
  90
  91 void
  92 stpwtch_stop (stopwatch_t *w)
  93 {
  94   if (w->start == 0)    /* if never started, ignore the call */
  95     return;
  96
  97   /* get stopping high-res time */
  98   w->tempus = gethrtime ();
  99
 100   /* bump count of stops */
 101   w->count++;
 102
 103   /* compute the delta for this call */
 104   w->delta = w->tempus - w->start;
 105
 106   /* add in this one */
 107   w->last = (double) (w->delta);
 108   w->sum = w->sum + w->last;
 109   w->sumsq = w->sumsq + w->last * w->last;
 110
 111   if (w->max == 0)
 112     w->max = w->last;
 113   else if (w->max < w->last)
 114     w->max = w->last;
 115   if (w->min == 0)
 116     w->min = w->last;
 117   else if (w->min > w->last)
 118     w->min = w->last;
 119
 120   /* show stopwatch stopped */
 121   w->start = 0;
 122 }
 123
 124 void
 125 stpwtch_print (stopwatch_t *w)
 126 {
 127   char cvdbuf[1024];
 128
 129   /* get stopping high-res time */
 130   w->tempus = gethrtime ();
 131   double duration = (double) (w->tempus - w->begin);
 132
 133   if (w->count == 0)
 134     sprintf (cvdbuf, "       0.       s. ( 0. %% of %12.6f s.) -- %s\n",
 135              (duration / 1000000000.), w->name);
 136   else if (w->count == 1)
 137     sprintf (cvdbuf, "    %12.6f s. (%4.1f %%%% of %.6f s.) -- %s\n",
 138              w->sum / 1000000000., (100. * w->sum) / duration,
 139              duration / 1000000000., w->name);
 140   else
 141     sprintf (cvdbuf,
 142              "    %12.6f s.  (%4.1f %%%% of %.6f s.) -- %s\n\tN = %d,"
 143              " avg = %.3f us., min = %.3f, max = %.3f\n",
 144              w->sum / 1000000000., (100. * w->sum) / duration,
 145              duration / 1000000000., w->name, w->count,
 146              w->sum / 1000. / ((double) (w->count > 0 ? w->count : 1)),
 147              ((double) w->min / 1000.), ((double) w->max / 1000.));
 148   fprintf (stderr, cvdbuf);
 149 }
 150
 151 /* hrtime routines */
 152 int
 153 whrlog (hrtime_t delta, char *event, char *string)
 154 {
 155   char buf[1024];
 156   if (string == NULL)
 157     sprintf (buf, "  %s secs. in %s\n", prhrdelta (delta), event);
 158   else
 159     sprintf (buf, "  %s secs. in %s\n\t%s\n", prhrdelta (delta), event, string);
 160   int bytes = fprintf (stderr, "%s", buf);
 161   return bytes;
 162 }
 163
 164 /* hrtime routines */
 165 int
 166 whrvlog (hrtime_t delta, hrtime_t vdelta, char *event, char *string)
 167 {
 168   char buf[1024];
 169   if (string == NULL)
 170     sprintf (buf, "  %s wall-secs., %s CPU-secs., in %s\n",
 171              prhrdelta (delta), prhrvdelta (vdelta), event);
 172   else
 173     sprintf (buf, "  %s wall-secs., %s CPU-secs., in %s\n\t%s\n",
 174              prhrdelta (delta), prhrvdelta (vdelta), event, string);
 175   int bytes = fprintf (stderr, "%s", buf);
 176   return bytes;
 177 }
 178
 179 /* prhrdelta (hrtime_t delta)
 180  *  returns a pointer to a static string in the form:
 181  *      sec.micros
 182  *       1.123456
 183  *      0123456789
 184  *
 185  *  prhrvdelta is the same, but uses a different static buffer
 186  */
 187 static char *
 188 prhrdelta (hrtime_t delta)
 189 {
 190   static char cvdbuf[26];
 191
 192   /* convert to seconds */
 193   double tempus = ((double) delta) / (double) 1000000000.;
 194   sprintf (cvdbuf, "%10.6f", tempus);
 195   return cvdbuf;
 196 }
 197
 198 static char *
 199 prhrvdelta (hrtime_t delta)
 200 {
 201   static char cvdbuf[26];
 202
 203   /* convert to seconds */
 204   double tempus = ((double) delta) / (double) 1000000000.;
 205   sprintf (cvdbuf, "%10.6f", tempus);
 206   return cvdbuf;
 207 }
 208
 209 /* time of day routines */
 210
 211 /* starting time - first timestamp; initialized on first call */
 212 static struct timeval starttime = {0, 0};
 213 static struct timeval ttime;        /* last-recorded timestamp */
 214 static struct timeval deltatime;    /* delta of last-rec'd timestamp */
 215
 216 static void
 217 snaptod ()
 218 {
 219   (void) gettimeofday (&ttime, NULL);
 220   if (starttime.tv_sec == 0)
 221     starttime = ttime;
 222
 223   deltatime.tv_sec = ttime.tv_sec - starttime.tv_sec;
 224   deltatime.tv_usec = ttime.tv_usec - starttime.tv_usec;
 225   while (deltatime.tv_usec < 0)
 226     {
 227       deltatime.tv_sec--;
 228       deltatime.tv_usec += 1000000;
 229     }
 230 }
 231
 232 int
 233 wlog (char *event, char *string)
 234 {
 235   char buf[1024];
 236
 237   snaptod ();
 238   if (string == NULL)
 239     sprintf (buf, "%s ===== (%d) %s\n", prdelta (deltatime),
 240              (int) getpid (), event);
 241   else
 242     sprintf (buf, "%s ===== (%d) %s\n\t%s\n", prdelta (deltatime),
 243              (int) getpid (), event, string);
 244   int bytes = fprintf (stderr, "%s", buf);
 245   return bytes;
 246 }
 247
 248 /* prtime (ttime)
 249  *  returns a pointer to a static string in the form:
 250  *      Thu  01 Jan 90  00:00:00\0
 251  *      01234567890122345678901234
 252  *
 253  *  ttime is a pointer to a UNIX time in seconds since epoch
 254  *  library routine localtime() is used
 255  */
 256 char *
 257 prtime (time_t *ttime)
 258 {
 259   static char *days[] = {
 260     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
 261   };
 262   static char *months[] = {
 263     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 264     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 265   };
 266   static char cvbuf[26];
 267
 268   /* get the date and time */
 269   struct tm *tp = localtime (ttime);
 270
 271   /* convert to string */
 272   sprintf (cvbuf, "%3s  %02d %s %02d  %02d:%02d:%02d", days[tp->tm_wday],
 273            tp->tm_mday, months[tp->tm_mon], tp->tm_year % 100,
 274            tp->tm_hour, tp->tm_min, tp->tm_sec);
 275   return cvbuf;
 276 }
 277
 278 char *
 279 prdelta (struct timeval tempus)
 280 {
 281   static char cvdbuf[26];
 282   while (tempus.tv_usec < 0)
 283     {
 284       tempus.tv_sec--;
 285       tempus.tv_usec += 1000000;
 286     }
 287   long seconds = tempus.tv_sec % 60;
 288   long minutes = tempus.tv_sec / 60;
 289   long hours = minutes / 60;
 290   minutes = minutes % 60;
 291   sprintf (cvdbuf, "%02ld:%02ld:%02ld.%03ld ",
 292            hours, minutes, seconds, (long) tempus.tv_usec / 1000);
 293   return cvdbuf;
 294 }