---

timer.h

// Emacs will be in -*- Mode: c++ -*-
//
// Hoard: A Fast, Scalable, and Memory-Efficient Allocator
//        for Shared-Memory Multiprocessors
// Contact author: Emery Berger, http://www.cs.utexas.edu/users/emery
//
// Copyright (c) 1998-2000, The University of Texas at Austin.
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as
// published by the Free Software Foundation, http://www.fsf.org.
//
// This 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
// Library General Public License for more details.
//


#ifndef _TIMER_H_
#define _TIMER_H_

#ifdef __SVR4 // Solaris
#include <sys/time.h>
#include <strstream.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/procfs.h>
#include <stdio.h>
#endif // __SVR4

#include <time.h>

#if defined(unix) || defined(__linux)
#include <sys/time.h>
#include <unistd.h>
#endif


#ifdef __sgi
#include <sys/types.h>
#include <sys/times.h>
#include <limits.h>
#endif


#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32)
#ifndef WIN32FLAG
#define WIN32FLAG 1
#endif
#include <windows.h>
#endif

#if defined(__BEOS__)
#include <OS.h>
#endif

class Timer {

public:
  Timer (void)
    : _starttime (0),
      _elapsedtime (0)
    {}

  void start (void) { _starttime = _time(); }

  void stop (void) { _elapsedtime += _time() - _starttime; }

  void reset (void) { _starttime = _elapsedtime = 0; }

  void set (double secs) { _starttime = 0; _elapsedtime = _sectotime (secs);}

  operator double (void) { return _timetosec (_elapsedtime); }


private:


#ifdef __sgi
#define TIMER_FOUND

  long _starttime, _elapsedtime;

  long _time (void) {
    struct tms t;
    long ticks = times (&t);
    return ticks;
  }

  double _timetosec (long t) {
    return ((double) (t) / CLK_TCK);
  }

  long _sectotime (double sec) {
    return (long) sec * CLK_TCK;
  }
#endif

#ifdef __SVR4 // Solaris
#define TIMER_FOUND
  hrtime_t  _starttime, _elapsedtime;

  virtual hrtime_t _time (void) {
    return gethrtime();
  }

  hrtime_t _sectotime (double sec) { return (hrtime_t) (sec * 1.0e9); }

  double _timetosec (hrtime_t& t) {
    return ((double) (t) / 1.0e9);
  }
#endif // __SVR4

#if defined(MAC) || defined(macintosh)
#define TIMER_FOUND
  double        _starttime, _elapsedtime;

  double _time (void) {
    return get_Mac_microseconds();
  }

  double _timetosec (hrtime_t& t) {
    return t;
  }
#endif // MAC

#ifdef WIN32FLAG
#define TIMER_FOUND
  DWORD _starttime, _elapsedtime;

  DWORD _time (void) {
    return GetTickCount();
  }

  double _timetosec (DWORD& t) {
    return (double) t / 1000.0;
  }

  unsigned long _sectotime (double sec) {
        return (unsigned long)(sec * 1000);
    }

#endif // WIN32


#ifdef __BEOS__
#define TIMER_FOUND
  bigtime_t _starttime, _elapsedtime;
  bigtime_t _time(void) {
    return system_time();
  }
  double _timetosec (bigtime_t& t) {
    return (double) t / 1000000.0;
  }
  
  bigtime_t _sectotime (double sec) {
    return (bigtime_t)(sec * 1000000.0);
  }
#endif // __BEOS__

#ifndef TIMER_FOUND

  long _starttime, _elapsedtime;

  long _time (void) {
    struct timeval t;
    struct timezone tz;
    gettimeofday (&t, &tz);
    return t.tv_sec * 1000000 + t.tv_usec;
  }

  double _timetosec (long t) {
    return ((double) (t) / 1000000);
  }

  long _sectotime (double sec) {
    return (long) sec * 1000000;
  }

#endif // TIMER_FOUND

#undef TIMER_FOUND

};


#ifdef __SVR4 // Solaris
class VirtualTimer : public Timer {
public:
  hrtime_t _time (void) {
    return gethrvtime();
  }
};  
#endif

#endif

---