timing.h

Go to the documentation of this file.

/** \file timing.h

  \brief Utilities for performing timing

*/

/**AutomaticStart*************************************************************/

/*---------------------------------------------------------------------------*/
/* Function prototypes                                                       */
/*---------------------------------------------------------------------------*/

/**AutomaticEnd***************************************************************/


#ifndef _TIMING
#define _TIMING

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <ctype.h>
#include <math.h>

#include <assert.h>
#include <time.h>


/**
  * \brief  An encapsulation of a pair of u_int32_t's used to manipulate times
  * 
  * An encapsulation of a pair of u_int32_t's used to manipulate times
  * 
  */


struct util_timing_t
{
  u_int32_t high;
  u_int32_t low;
};

typedef struct util_timing_t util_timing_t;


extern double PROCESSOR_FREQUENCY;

/* From /usr/src/linux-2.4.20-8/include/asm-i386/msr.h
 *
 * Useful for very precise timing
 * 
 * Access to machine-specific registers (available on 586 and better only)
 * Note: the rd* operations modify the parameters directly (without using
 * pointer indirection), this allows gcc to optimize better
 *
 */

#define rdmsr(msr,val1,val2) \
     __asm__ __volatile__("rdmsr" \
                          : "=a" (val1), "=d" (val2) : "c" (msr))

#define wrmsr(msr,val1,val2) \
     __asm__ __volatile__("wrmsr" \
                          : /* no outputs */ \
                          : "c" (msr), "a" (val1), "d" (val2))

#define rdtsc(low,high) \
     __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))

#define rdtscl(low) \
     __asm__ __volatile__("rdtsc" : "=a" (low) : : "edx")

#define rdtscll(val) \
     __asm__ __volatile__("rdtsc" : "=A" (val))

#define write_tsc(val1,val2) wrmsr(0x10, val1, val2)

#define rdpmc(counter,low,high) \
     __asm__ __volatile__("rdpmc" \
                          : "=a" (low), "=d" (high) \
                          : "c" (counter))


/**
  * \brief Set the low and high fields in the struct based on current time
  */

static inline void
util_timing_set (util_timing_t * time)
{
  rdtsc (time->low, time->high);
}


/**
  * \brief Form the difference arg1 - arg2 of the times denoted by arg1 and arg2,
  *     arg1 is assumed to be larger than arg2
  */

static inline util_timing_t
util_timing_diff (util_timing_t arg1, util_timing_t arg2)
{
  util_timing_t result;

  if (arg1.low >= arg2.low)
    {
      // ( 5, 6 ) - ( 4, 5 ) = ( 1, 1 ) 
      // ( 5, 5 ) - ( 4, 5 ) = ( 1, 0 ) 
      result.low = arg1.low - arg2.low;
      result.high = arg1.high - arg2.high;
    }
  else
    {
      // ( 5, 5 ) - ( 4, 6 ) = ( 0, 9 ) 
      assert (arg1.high > arg2.high);
      result.low = (~((u_int32_t) (0)) - arg2.low) + arg1.low;
      result.high = arg1.high - arg2.high - 1;
    }
  return result;
}


/**
  * \brief  Return 64-bit time in seconds
  * 
  */

static inline double
util_timing_secs (util_timing_t time)
{
  double low = (double) time.low;
  double high = (double) time.high;

  double maxInt = 1.0 + (double) (~((u_int32_t) 0));
  double tick = 1.0 / PROCESSOR_FREQUENCY;

  double delta = (tick) * ((low) + maxInt * high);

  return delta;
}


/**
  * \brief Return the current time, in seconds
  */

static inline double
util_timing_now ()
{
  util_timing_t now;
  double result;
  util_timing_set (&now);
  result = util_timing_secs (now);

  return result;
}


/**
  * \brief  Check if arg1 reps a lesser time than arg2
  * 
  */

static inline int
util_timing_compare (util_timing_t arg1, util_timing_t arg2)
{
  if (arg1.high < arg2.high)
    {
      return 1;
    }
  else if ((arg1.high == arg2.high) && (arg1.low < arg2.low))
    {
      return 1;
    }
  else
    {
      return 0;
    }
}


/**
  * \brief  Convert a time specifed as a double to an rdtsc pair
  * 
  */

static inline util_timing_t
util_timing_pair (double time)
{
  util_timing_t result;
  double maxInt = 1.0 + (double) (~((u_int32_t) 0));
  double tick = 1.0 / PROCESSOR_FREQUENCY;

  double tickTime = time / tick;

  double hightime = floor (tickTime / maxInt);
  double lowtime = tickTime - (hightime * maxInt);

  result.low = lowtime;
  result.high = hightime;

  return result;
}

/**
  * \brief Pause for pauseTime
  */

static inline void
util_timing_pause (util_timing_t pauseTime)
{
  util_timing_t startTime, currentTime, diffTime;
  if ((pauseTime.low == 0) && (pauseTime.high == 0))
    {
      return;
    }
  util_timing_set (&startTime);

  while (1)
    {
      util_timing_set (&currentTime);
      diffTime = util_timing_diff (currentTime, startTime);
      // check if pauseTime is less than diffTime
      if (util_timing_compare (pauseTime, diffTime))
    {
      return;
    }
    }
}


/**
  * \brief Pause for T seconds.
  */

static inline void
util_timing_pause_secs (double T)
{
  util_timing_t pauseTime = util_timing_pair (T);
  util_timing_pause (pauseTime);
}

#ifdef __cplusplus
}
#endif

#endif /* _TIMING */