path: root/tune/time.c

/* Time routines for speed measurments. */

/*
Copyright (C) 1999, 2000 Free Software Foundation, Inc.

This file is part of the GNU MP Library.

The GNU MP Library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or (at your
option) any later version.

The GNU MP Library 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 Lesser General Public
License for more details.

You should have received a copy of the GNU Lesser General Public License
along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA.
*/

/* speed_time_init() - initialize timing things.  speed_starttime() calls
   this if it hasn't been done yet, so you only need to call this explicitly
   if you want to use the global variables before the first measurement.
  
   speed_starttime() - start a time measurment.

   speed_endtime() - end a time measurment, return time taken, in seconds.

   speed_unittime - global variable with the unit of time measurement
   accuracy, in seconds.

   speed_precision - global variable which is the intended accuracy of time
   measurements.  speed_measure() for instance runs target routines with
   enough repetitions so it takes at least speed_unittime*speed_precision
   seconds.  A program can provide an option so the user can set this.

   speed_cycletime - the time in seconds for each CPU cycle, for example on
   a 100 MHz CPU this would be 1.0e-8.  If the CPU frequency is unknown,
   speed_cycletime is 1.0.  See speed_cycletime_init().

   speed_time_string - a string describing the time method in use.


   Enhancements:

   Add support for accurate timing on more CPUs, machines and systems.

   Extend automatic CPU frequency determination to more kernels and systems.

 */


#include <stdio.h>
#include <stdlib.h> /* for getenv */
#if HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <sys/types.h>
#if HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
#endif

#include "gmp.h"
#include "gmp-impl.h"
#include "longlong.h"

#include "speed.h"


#if HAVE_SPEED_CYCLECOUNTER
#define SPEED_USE_CYCLECOUNTER               1
#else
#define SPEED_USE_MICROSECOND_GETRUSAGE      0
#define SPEED_USE_MICROSECOND_GETTIMEOFDAY   1
#define SPEED_USE_TMS_UTIME                  0
#endif


#define TIMEVAL_SECS(tp) \
  ((double) (tp)->tv_sec + (double) (tp)->tv_usec * 1.0e-6)


/* Look for an environment variable for CPU clock frequency.
   GMP_CPU_FREQUENCY should be in Hertz, in floating point form,
   eg. "450e6". */
int
speed_cpu_frequency_environment (void)
{
  char  *e;

  e = getenv ("GMP_CPU_FREQUENCY");
  if (e == NULL)
    return 0;

  speed_cycletime = 1.0 / atof (e);
  return 1;
}


/* On FreeBSD 3.3 the headers have #defines like CPU_WALLCLOCK under
   CTL_MACHDEP but don't seem to have anything for machdep.tsc_freq or
   machdep.i586_freq.  Using the string forms with sysctlbyname() works
   though, and lets libc worry about the defines and headers.

   FreeBSD 3.3 has tsc_freq, FreeBSD 2.2.8 has i586_freq instead.
   The "sysctl -a" command prints everything available. */

#if HAVE_SYSCTLBYNAME
int
speed_cpu_frequency_sysctlbyname (void)
{
  unsigned  val;
  size_t    valsize;

  valsize = sizeof(val);
  if (sysctlbyname ("machdep.tsc_freq", &val, &valsize, NULL, 0) != 0
      || valsize != sizeof(val))
    {
      valsize = sizeof(val);
      if (sysctlbyname ("machdep.i586_freq", &val, &valsize, NULL, 0) != 0
          || valsize != sizeof(val))
        return 0;
    }

  speed_cycletime = 1.0 / (double) val;
  return 1;
}
#endif


/* Linux doesn't seem to have any system call to get the CPU frequency, at
   least not in 2.0.x or 2.2.x, so it's necessary to read /proc/cpuinfo.

   Kernel 2.0.36 has "bogomips", and it's the CPU frequency.  Kernel 2.2.13
   has both a "cpu MHz" and "bogomips", and it's "cpu MHz" which is the
   frequency.  */

int
speed_cpu_frequency_proc_cpuinfo (void)
{
  FILE    *fp;
  char    buf[128];
  double  val;
  int     ret = 0;

  if ((fp = fopen ("/proc/cpuinfo", "r")) != NULL)
    {
      while (fgets (buf, sizeof (buf), fp) != NULL)
        {
          if (sscanf (buf, "cpu MHz  : %lf\n", &val) == 1)
            {
              speed_cycletime = 1e-6 / val;
              ret = 1;
              break;
            }
          if (sscanf (buf, "bogomips : %lf\n", &val) == 1)
            {
              speed_cycletime = 1e-6 / val;
              ret = 1;
              break;
            }
        }
      fclose (fp);
    }
  return ret;
}


/* SunOS /bin/sysinfo prints a line like:
       cpu0 is a "75 MHz TI,TMS390Z55" CPU */

#if HAVE_POPEN
int
speed_cpu_frequency_sunos_sysinfo (void)
{
  FILE    *fp;
  char    buf[128];
  double  val;
  int     ret = 0;

  /* Error messages are sent to /dev/null in case /bin/sysinfo doesn't
     exist.  The brackets are necessary for some shells (eg. ash). */
  if ((fp = popen ("(/bin/sysinfo) 2>/dev/null", "r")) != NULL)
    {
      while (fgets (buf, sizeof (buf), fp) != NULL)
        {
          if (sscanf (buf, " cpu0 is a \"%lf MHz", &val) == 1)
            {
              speed_cycletime = 1e-6 / val;
              ret = 1;
              break;
            }
        }
      pclose (fp);
    }
  return ret;
}
#endif


/* This is for Solaris.  "psrinfo" is the command-line interface to
   processor_info().  "prtconf -vp" gives similar information.  */

#if HAVE_PROCESSOR_INFO
#include <sys/unistd.h>     /* for _SC_NPROCESSORS_CONF */
#include <sys/processor.h>  /* for processor_info_t */
int
speed_cpu_frequency_processor_info (void)
{
  processor_info_t  p;
  int  i, n, mhz = 0;

  n = sysconf (_SC_NPROCESSORS_CONF);
  for (i = 0; i < n; i++)
    {
      if (processor_info (i, &p) != 0)
        continue;
      if (p.pi_state != P_ONLINE)
        continue;

      if (mhz != 0 && p.pi_clock != mhz)
        {
          fprintf (stderr,
                   "speed_cpu_frequency_processor_info(): There's more than one CPU and they have different clock speeds\n");
          return 0;
        }

      mhz = p.pi_clock;
    }

  speed_cycletime = 1.0e-6 / (double) mhz;
  return 1;
}
#endif


/* Each function returns 1 if it succeeds in setting speed_cycletime, or 0
   if not.  */

static const struct {
  int         (*fun) _PROTO ((void));
  const char  *description;

} speed_cpu_frequency_table[] = {

  /* This should be first, so an environment variable can override anything
     the system gives. */
  { speed_cpu_frequency_environment,
    "environment variable GMP_CPU_FREQUENCY (in Hertz)" },

#if HAVE_SYSCTLBYNAME
  { speed_cpu_frequency_sysctlbyname,
    "sysctlbyname() machdep.tsc_freq or machdep.i586_freq" },
#endif

#if HAVE_PROCESSOR_INFO
  { speed_cpu_frequency_processor_info,
    "processor_info() pi_clock" },
#endif

  { speed_cpu_frequency_proc_cpuinfo,
    "linux kernel /proc/cpuinfo file, cpu MHz or bogomips" },

#if HAVE_POPEN
  { speed_cpu_frequency_sunos_sysinfo,
    "SunOS /bin/sysinfo program cpu0 output" },
#endif
};


int
speed_cycletime_init (void)
{
  int  i;

  for (i = 0; i < numberof (speed_cpu_frequency_table); i++)
    if ((*speed_cpu_frequency_table[i].fun)())
      return 1;

  fprintf (stderr,
           "Cannot determine CPU frequency, need one of the following\n");
  for (i = 0; i < numberof (speed_cpu_frequency_table); i++)
    fprintf (stderr, "\t%s\n", speed_cpu_frequency_table[i].description);

  return 0;
}


/* ---------------------------------------------------------------------- */
#if SPEED_USE_CYCLECOUNTER

const char *speed_time_string 
  = "Time measurements using CPU cycle counter.\n";

/* bigish value because we have a fast timer */
int speed_precision = 10000;

double speed_unittime;
double speed_cycletime;

static int  speed_time_initialized = 0;
static unsigned  speed_starttime_save[2];

/* Knowing the CPU frequency is mandatory, so cycles can be converted to
   seconds.  */
void
speed_time_init (void)
{
  if (speed_time_initialized)
    return;
  speed_time_initialized = 1;

  if (!speed_cycletime_init ())
    exit (1);

  speed_unittime = speed_cycletime;
}

void
speed_starttime (void)
{
  if (!speed_time_initialized)
    speed_time_init ();
  speed_cyclecounter (speed_starttime_save);
}

#ifndef UINT_BIT
#define UINT_BIT  (sizeof (unsigned) * 8)
#endif
#define M_2POWU   ((double) (1L << (UINT_BIT-2)) * 4.0)
#define M_2POW32  4294967296.0

double
speed_endtime (void)
{
  unsigned  endtime[2], e0;
  double    t;

  speed_cyclecounter (endtime);

  /* This still works even if speed_cyclecounter() puts a value bigger than
     32-bits in the low word.  The start and end values are allowed to
     cancel in uints in case a uint is more than the 53 bits that will
     normally fit in a double. */
  e0 = endtime[0] - speed_starttime_save[0];
  t = e0 - (e0 > endtime[0] ? M_2POWU : 0);
  t += (endtime[1] - speed_starttime_save[1]) * M_2POW32;

  return t * speed_unittime;
}

#endif


/* ---------------------------------------------------------------------- */
#if SPEED_USE_MICROSECOND_GETRUSAGE
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>

const char *speed_time_string
  = "Time measurements using microsecond accurate getrusage.\n";

int speed_precision = 1000;

double speed_unittime = 1.0e-6;
double speed_cycletime = 1.0;

static struct rusage  speed_starttime_save;
static int  speed_time_initialized = 0;

void
speed_time_init (void)
{
  if (speed_time_initialized)
    return;
  speed_time_initialized = 1;

  speed_cycletime_init ();
}

void
speed_starttime (void)
{
  if (!speed_time_initialized)
    speed_time_init ();

  getrusage (0, &speed_starttime_save);
}

double
speed_endtime (void)
{
  struct rusage r;

  getrusage (0, &r);
  return TIMEVAL_SECS (&r.ru_utime)
    - TIMEVAL_SECS (&speed_starttime_save.ru_utime);
}
#endif


/* ---------------------------------------------------------------------- */
#if SPEED_USE_MICROSECOND_GETTIMEOFDAY
/* This method is for systems with a microsecond accurate gettimeofday().

   A dummy timezone parameter is always given to gettimeofday(), in case it
   doesn't allow NULL.  */

#include <sys/time.h>

const char *speed_time_string 
  = "Time measurements using microsecond accurate gettimeofday.\n";

/* highish value because we have an accurate timer */
int speed_precision = 1000;

double speed_unittime = 1.0e-6;
double speed_cycletime = 1.0;

static struct timeval  speed_starttime_save;
static int  speed_time_initialized = 0;

void
speed_time_init (void)
{
  if (speed_time_initialized)
    return;
  speed_time_initialized = 1;

  speed_cycletime_init ();
}

void
speed_starttime (void)
{
  struct timezone  tz;
  if (!speed_time_initialized)
    speed_time_init ();

  gettimeofday (&speed_starttime_save, &tz);
}

double
speed_endtime (void)
{
  struct timeval   t;
  struct timezone  tz;

  gettimeofday (&t, &tz);
  return TIMEVAL_SECS (&t) - TIMEVAL_SECS (&speed_starttime_save);
}

#endif


/* ---------------------------------------------------------------------- */
#if SPEED_USE_TMS_UTIME
/* You're in trouble if you have to use this method.  Speed measurments and
   threshold tuning are going to take a long time. */

#if STDC_HEADERS
#include <errno.h>      /* for errno */
#include <string.h>     /* for strerror */
#endif
#if HAVE_UNISTD_H
#include <unistd.h>     /* for sysconf */
#endif
#include <sys/times.h>  /* for times */

const char *speed_time_string 
  = "Time measurements using tms_utime.\n";


/* lowish default value so we don't take days and days to do tuning */
int  speed_precision = 200;

double  speed_unittime;
double  speed_cycletime = 1.0;

static struct tms  speed_starttime_save;
static int  speed_time_initialized = 0;

void
speed_time_init (void)
{
  long  clk_tck;

  if (speed_time_initialized)
    return;
  speed_time_initialized = 1;

  speed_cycletime_init ();

#if HAVE_SYSCONF
  clk_tck = sysconf (_SC_CLK_TCK);
  if (clk_tck == -1L)
    {
      fprintf (stderr, "sysconf(_SC_CLK_TCK) not available: %s\n",
	       strerror(errno));
      fprintf (stderr, "\tusing CLK_TCK instead\n");
      clk_tck = CLK_TCK;
    }
#else
  clk_tck = CLK_TCK;
#endif

  speed_unittime = 1.0 / (double) clk_tck;
}

/* Burn up CPU until a times() tms_utime tick boundary.
   Doing so lets you know a measurement has started on a tick boundary,
   effectively halving the uncertainty in the measurement.
   *t1 gets the start times() values the caller should use. */
void
times_utime_boundary (struct tms *t1)
{
  struct tms  t2;
  times (&t2);
  do
    times (t1);
  while (t1->tms_utime == t2.tms_utime);
}

void
speed_starttime (void)
{
  if (!speed_time_initialized)
    speed_time_init ();
  times_utime_boundary (&speed_starttime_save);
}

double
speed_endtime (void)
{
  struct tms  t;
  times (&t);
  return (t.tms_utime - speed_starttime_save.tms_utime) * speed_unittime;
}

#endif