CycleTimer Namespace Reference

This uses the cycle counter of the processor. More...

Typedefs
typedef unsigned long long	SysClock

Functions
SysClock	currentTicks ()
	Return the current CPU time, in terms of clock ticks. More...
const char *	tickUnits ()
double	secondsPerTick ()
	Return the conversion from ticks to seconds. More...
double	msPerTick ()
	Return the conversion from ticks to milliseconds. More...
double	currentSeconds ()
	Return the current CPU time, in terms of seconds. More...
double	ticksPerSecond ()
	Return the conversion from seconds to ticks. More...

Detailed Description

This uses the cycle counter of the processor.

Different processors in the system will have different values for this. If you process moves across processors, then the delta time you measure will likely be incorrect. This is mostly for fine grained measurements where the process is likely to be on the same processor. For more global things you should use the Time interface.

Also note that if you processors' speeds change (i.e. processors scaling) or if you are in a heterogenous environment, you will likely get spurious results.

Typedef Documentation

typedef unsigned long long CycleTimer::SysClock

Definition at line 37 of file cycletimer.hpp.

Function Documentation

double CycleTimer::currentSeconds ( )

inline

Return the current CPU time, in terms of seconds.

This is slower than currentTicks(). Time zero is at some arbitrary point in the past.

Definition at line 157 of file cycletimer.hpp.

References currentTicks(), and secondsPerTick().

Referenced by bench_oxford(), and benchmark_dataset().

                                 {
    return currentTicks() * secondsPerTick();
  }

SysClock CycleTimer::currentTicks ( )

inline

Return the current CPU time, in terms of clock ticks.

Time zero is at some arbitrary point in the past.

Definition at line 41 of file cycletimer.hpp.

Referenced by currentSeconds().

                                 {
#if defined(__APPLE__) && !defined(__x86_64__)
    return mach_absolute_time();
#elif defined(_WIN32)
    LARGE_INTEGER qwTime;
    QueryPerformanceCounter(&qwTime);
    return qwTime.QuadPart;
#elif defined(__x86_64__)
    unsigned int a, d;
    asm volatile("rdtsc" : "=a" (a), "=d" (d));
    return static_cast<unsigned long long>(a) |
      (static_cast<unsigned long long>(d) << 32);
#elif defined(__ARM_NEON__) && 0 // mrc requires superuser.
    unsigned int val;
    asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r"(val));
    return val;
#else
    timespec spec;
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &spec);
    return CycleTimer::SysClock(static_cast<float>(spec.tv_sec) * 1e9 + static_cast<float>(spec.tv_nsec));
#endif
  }

double CycleTimer::msPerTick ( )

inline

Return the conversion from ticks to milliseconds.

Definition at line 150 of file cycletimer.hpp.

References secondsPerTick().

                            {
    return secondsPerTick() * 1000.0;
  }

double CycleTimer::secondsPerTick ( )

inline

Return the conversion from ticks to seconds.

Definition at line 75 of file cycletimer.hpp.

Referenced by currentSeconds(), msPerTick(), and ticksPerSecond().

                                 {
    static bool initialized = false;
    static double secondsPerTick_val;
    if (initialized) return secondsPerTick_val;
#if defined(__APPLE__)
#ifdef __x86_64__
    int args[] = {CTL_HW, HW_CPU_FREQ};
    unsigned int Hz;
    size_t len = sizeof(Hz);
    if (sysctl(args, 2, &Hz, &len, NULL, 0) != 0) {
       fprintf(stderr, "Failed to initialize secondsPerTick_val!\n");
       exit(-1);
    }
    secondsPerTick_val = 1.0 / (double) Hz;
#else
    mach_timebase_info_data_t time_info;
    mach_timebase_info(&time_info);

    // Scales to nanoseconds without 1e-9f
    secondsPerTick_val = (1e-9*static_cast<double>(time_info.numer))/
      static_cast<double>(time_info.denom);
#endif // x86_64 or not
#elif defined(_WIN32)
    LARGE_INTEGER qwTicksPerSec;
    QueryPerformanceFrequency(&qwTicksPerSec);
    secondsPerTick_val = 1.0/static_cast<double>(qwTicksPerSec.QuadPart);
#else
    FILE *fp = fopen("/proc/cpuinfo","r");
    char input[1024];
    if (!fp) {
       fprintf(stderr, "CycleTimer::resetScale failed: couldn't find /proc/cpuinfo.");
       exit(-1);
    }
    // In case we don't find it, e.g. on the N900
    secondsPerTick_val = 1e-9;
    while (!feof(fp) && fgets(input, 1024, fp)) {
      // NOTE(boulos): Because reading cpuinfo depends on dynamic
      // frequency scaling it's better to read the @ sign first
      float GHz, MHz;
      if (strstr(input, "model name")) {
        char* at_sign = strstr(input, "@");
        if (at_sign) {
          char* after_at = at_sign + 1;
          char* GHz_str = strstr(after_at, "GHz");
          char* MHz_str = strstr(after_at, "MHz");
          if (GHz_str) {
            *GHz_str = '\0';
            if (1 == sscanf(after_at, "%f", &GHz)) {
              //printf("GHz = %f\n", GHz);
              secondsPerTick_val = 1e-9f / GHz;
              break;
            }
          } else if (MHz_str) {
            *MHz_str = '\0';
            if (1 == sscanf(after_at, "%f", &MHz)) {
              //printf("MHz = %f\n", MHz);
              secondsPerTick_val = 1e-6f / GHz;
              break;
            }
          }
        }
      } else if (1 == sscanf(input, "cpu MHz : %f", &MHz)) {
        //printf("MHz = %f\n", MHz);
        secondsPerTick_val = 1e-6f / MHz;
        break;
      }
    }
    fclose(fp);
#endif

    initialized = true;
    return secondsPerTick_val;
  }

double CycleTimer::ticksPerSecond ( )

inline

Return the conversion from seconds to ticks.

Definition at line 162 of file cycletimer.hpp.

References secondsPerTick().

                                 {
    return 1.0/secondsPerTick();
  }

const char* CycleTimer::tickUnits ( )

inline

Definition at line 64 of file cycletimer.hpp.

                                 {
#if defined(__APPLE__) && !defined(__x86_64__)
    return "ns";
#elif defined(__WIN32__) || defined(__x86_64__)
    return "cycles";
#else
    return "ns"; // clock_gettime
#endif
  }