#include <sys/time.h>
#include <unistd.h>

#ifndef _TIMER_H_
#define _TIMER_H_

#ifdef i386
#include <sched.h>
class timer {
public:
  typedef unsigned long long int timer_t;

  timer() : total_time(0) {
    clock_per_second = calibrate();
  }

  timer(double cps) : total_time(0), clock_per_second(cps) {
    raise_priority();
  }

  void raise_priority() {
    struct sched_param sp;
    sp.sched_priority = 99;
    sched_setscheduler(0, SCHED_FIFO, &sp); // effective only for root user
  }

  void reset_priority() {
    struct sched_param sp;
    sp.sched_priority = 0;
    sched_setscheduler(0, SCHED_OTHER, &sp); // effective only for root user
  }

  double calibrate() {
    timer_t t1, t2;
    struct timeval tv1, tv2;
    double diff_gettimeofday, diff_clock;

    gettimeofday (&tv1, NULL);
    t1 = read_timer();
    sleep (3);
    gettimeofday (&tv2, NULL);
    t2 = read_timer();
    diff_gettimeofday = (((tv2.tv_sec - tv1.tv_sec) * 1000000.0
                          + tv2.tv_usec - tv1.tv_usec) / 1000000.0);
    diff_clock = (double)t2 - (double)t1;
    return diff_clock / diff_gettimeofday;
  }

  timer_t read_timer() {
    unsigned long long int x;
    __asm__ __volatile__ (".byte 0x0f, 0x31" : "=A" (x));
    return x;
  }

  void reset() { running = 0; total_time = 0; }
  
  void restart() {
    if (! (running & 1))
      {
        ++running;
        raise_priority();
        start_time = read_timer();
      }
  }
  
  void pause() {
    // reads timer only if running.
    if (running & 1)
      {
        total_time += read_timer() - start_time;
        reset_priority();
        ++running;
      }
  }
  
  unsigned npause() {
    return running / 2;
  }
  
  double elapsed() {
    pause();
    return static_cast<double>(total_time) / clock_per_second;
  }

private:
  unsigned running; // odd if running, even if not running.
  timer_t start_time, total_time;
  double clock_per_second;
};
#endif // i386

#ifdef sparc
class timer {
public:
  typedef hrtime_t timer_t;

  timer() : total_time(0), clock_per_second(1000000000.0) { }
  timer(double) : total_time(0), clock_per_second(1000000000.0) { }
  timer_t read_timer() { return gethrvtime(); }

  void raise_priority() { }
  void reset_priority() { }

  void reset() { running = 0; total_time = 0; }
  
  void restart() {
    if (! (running & 1))
      {
        ++running;
        raise_priority();
        start_time = read_timer();
      }
  }
  
  void pause() {
    // reads timer only if running.
    if (running & 1)
      {
        total_time += read_timer() - start_time;
        reset_priority();
        ++running;
      }
  }
  
  unsigned npause() {
    return running / 2;
  }
  
  double elapsed() {
    pause();
    return static_cast<double>(total_time) / clock_per_second;
  }

private:
  unsigned running; // odd if running, even if not running.
  timer_t start_time, total_time;
  double clock_per_second;
};
#endif // sparc

#endif // _TIMER_H_