util.c

Go to the documentation of this file.

/** \file util.c

\brief Variety of utility functions for timing analysis.

*/

#include "util.h"

static int initialized = 0;

double PROCESSOR_FREQUENCY = 1000000000.0;

static struct timeval t0;
static struct timeval t1;
static struct timeval delta;

static struct timeval
mintimeval (struct timeval a, struct timeval b)
{
  if ((a.tv_sec < b.tv_sec) ||
      ((a.tv_sec == b.tv_sec) && (a.tv_usec < b.tv_usec)))
    {
      return a;
    }
  return b;
}

static struct timeval
maxtimeval (struct timeval a, struct timeval b)
{
  struct timeval mintime = mintimeval (a, b);
  if (mintime.tv_sec == a.tv_sec && mintime.tv_usec == a.tv_usec)
    {
      return b;
    }
  return a;
}

void
util_set_processor_frequency ()
{
  struct timeval startTime;
  struct timeval finishTime;
  util_timing_t startRdtsc;
  util_timing_t finishRdtsc;

  int numIter = 1000000;
  int i;

  gettimeofday (&startTime, NIL (struct timezone));
  util_timing_set (&startRdtsc);
  for (i = 0; i < numIter; i++)
    {
      /* 
       * Historically, GCC has not deleted “empty” loops under the assumption that 
       * the most likely reason you would put one in a program is to have a delay, 
       * so deleting them will not make real programs run any faster. 
       *
       */
    }
  gettimeofday (&finishTime, NIL (struct timezone));
  util_timing_set (&finishRdtsc);

  struct timeval deltaTime;
  if (startTime.tv_usec <= finishTime.tv_usec)
    {
      deltaTime.tv_usec = finishTime.tv_usec - startTime.tv_usec;
      deltaTime.tv_sec = finishTime.tv_sec - startTime.tv_sec;
    }
  else
    {
      deltaTime.tv_usec = 1000000 + finishTime.tv_usec - startTime.tv_usec;
      deltaTime.tv_sec = finishTime.tv_sec - startTime.tv_sec - 1;
    }

  double numCycles;
  if (startRdtsc.low < finishRdtsc.low)
    {
      numCycles = (double) (finishRdtsc.low - startRdtsc.low);
    }
  else
    {
      numCycles = (double) ((~(0x0) - startRdtsc.low) + finishRdtsc.low);
    }

  double deltaDouble = ((double) deltaTime.tv_sec) +
    (0.000001 * ((double) deltaTime.tv_usec));

  PROCESSOR_FREQUENCY = numCycles / deltaDouble;

  printf ("Processor freq appears to be %.2f\n", PROCESSOR_FREQUENCY);

}

void
util_time (char *mesg)
{
  // struct timezone tz;
  // bzero( ( char * ) & tz, sizeof( tz ) );

  if (initialized == 0)
    {
      gettimeofday (&t0, NIL (struct timezone));
      gettimeofday (&t1, NIL (struct timezone));
      initialized = 1;
      return;
    }
  gettimeofday (&t1, NIL (struct timezone));

  static struct timeval tmpmin;
  static struct timeval tmpmax;

  tmpmin = t0;
  tmpmax = t1;

  if (tmpmin.tv_usec <= tmpmax.tv_usec)
    {
      delta.tv_usec = tmpmax.tv_usec - tmpmin.tv_usec;
      delta.tv_sec = tmpmax.tv_sec - tmpmin.tv_sec;
    }
  else
    {
      delta.tv_usec = 1000000 + tmpmax.tv_usec - tmpmin.tv_usec;
      delta.tv_sec = tmpmax.tv_sec - tmpmin.tv_sec - 1;
    }

  printf ("Run time for %s is %d sec, %d usec\n",
      mesg, delta.tv_sec, delta.tv_usec);

  t0 = t1;
}

/**
  * \brief  Convert time in seconds to machine ticks; use in 
  * conjunction with rdtsc-type instructions
  * 
  * Convert time in seconds to machine ticks; use in 
  * conjunction with rdtsc-type instructions
  * 
  */



u_int32_t
util_time_to_ticks (double secs)
{
  u_int32_t result;
  result = (unsigned int) (secs * (PROCESSOR_FREQUENCY));

  return result;
}

int
test_time ()
{
  util_time ("foo");

  int i;
  for (i = 0; i < 1000000000; i++)
    {
      int y = i * i;
    }
  util_time ("took so long");
  return 0;
}


array_t *
util_time_stamp_init (int N)
{
  array_t *timeStamps = array_alloc (util_timing_t, N);
  int i;
  util_timing_t dummy;
  for (i = 0; i < N; i++)
    {
      array_insert (util_timing_t, timeStamps, i, dummy);
    }
  return timeStamps;
}

void
util_time_stamp_set (array_t * timeStamps, int i)
{
  util_timing_t iTime;
  util_timing_set (&iTime);

  array_insert (util_timing_t, timeStamps, i, iTime);

  return;
}

void
util_time_stamp_print (array_t * timeStamps)
{
  int i;
  for (i = 0; i < (array_n (timeStamps) - 1); i++)
    {
      util_timing_t t0 = array_fetch (util_timing_t, timeStamps, i);
      util_timing_t t1 = array_fetch (util_timing_t, timeStamps, (i + 1));
      util_timing_t diffTime = util_timing_diff (t1, t0);
      printf ("Time for call\t%d is\t%.3f usec\n", i,
          1000000.0 * util_timing_secs (diffTime));
    }
  return;
}


/**
  * \brief Code to test timing routines in timing.h
  */