read_timing_common.H

Go to the documentation of this file.

// Copyright (C) 2004, Kenneth C. Schalk
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta 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
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

// read_timing_common.H - common code used in both read_timing.C and
// read_lock_timing.C

// Last modified on Tue Dec  7 19:21:07 EST 2004 by ken@xorian.net

#include <sys/time.h> /* struct timeval */

#include <FS.H>

#include <stdio.h>

#define USECS_PER_SEC 1000000

struct Delta_Time
{
  unsigned long secs;
  unsigned long usecs;

  // Read a Delta_Time from a file.
  void read(FILE *input) throw(FS::EndOfFile)
  {
    unsigned short file_secs;
    size_t n_read =
      fread((void *) &file_secs, sizeof(file_secs), 1, input);
    if(n_read < 1)
      {
        throw FS::EndOfFile();
      }
    assert(n_read == 1);
    secs = file_secs;
    unsigned int file_usecs;
    n_read = fread((void *) &file_usecs, sizeof(file_usecs), 1, input);
    if(n_read < 1)
      {
        throw FS::EndOfFile();
      }
    assert(n_read == 1);
    usecs = file_usecs;
  }

  Delta_Time(FILE *input) throw(FS::EndOfFile)
  {
    read(input);
  }

  Delta_Time()
    : secs(0), usecs(0)
  {
  }

  // Correct overflow of usecs by converting to secs.
  void usecs_overflow()
  {
    if(usecs > USECS_PER_SEC)
      {
        secs += usecs/USECS_PER_SEC;
        usecs %= USECS_PER_SEC;
      }
  }

  bool operator>(const Delta_Time &other) const
  {
    return ((secs > other.secs) ||
            ((secs == other.secs) &&
             (usecs > other.usecs)));
  }

  bool operator>=(const Delta_Time &other) const
  {
    return ((secs > other.secs) ||
            ((secs == other.secs) &&
             (usecs >= other.usecs)));
  }

  Delta_Time operator-(const Delta_Time &other) const
  {
    Delta_Time result;

    if(secs == other.secs)
      {
        result.secs = 0;
        assert(usecs >= other.usecs);
        result.usecs = usecs - other.usecs;
      }
    else
      {
        assert(secs > other.secs);
        result.secs = (secs - other.secs) - 1;
        result.usecs = (usecs + USECS_PER_SEC) - other.usecs;
        result.usecs_overflow();
      }

    return result;
  }

  Delta_Time operator+(const Delta_Time &other) const
  {
    Delta_Time result;

    result.secs = secs + other.secs;
    result.usecs = usecs + other.usecs;
    result.usecs_overflow();

    return result;
  }

  Delta_Time &operator+=(const Delta_Time &other)
  {
    secs += other.secs;
    usecs += other.usecs;
    usecs_overflow();

    return *this;
  }

  Delta_Time &operator=(const Delta_Time &other)
  {
    secs = other.secs;
    usecs = other.usecs;

    return *this;
  }

  double msecs() const
  {
    double result = ((double) usecs) / 1000;
    result += secs*1000;
    return result;
  }

  bool operator==(const Delta_Time &other) const throw()
  {
    return ((secs == other.secs) && (usecs == other.usecs));
  }

  bool operator!=(const Delta_Time &other) const throw()
  {
    return ((secs != other.secs) && (usecs != other.usecs));
  }
};

inline struct timeval operator+(const struct timeval &start,
                                const Delta_Time &delta)
{
  struct timeval result = start;
  result.tv_sec += delta.secs;
  result.tv_usec += delta.usecs;
  if(result.tv_usec > USECS_PER_SEC)
    {
      result.tv_sec += result.tv_usec/USECS_PER_SEC;
      result.tv_usec %= USECS_PER_SEC;
    }
  return result;
}

Delta_Time operator-(const struct timeval &end,
                     const struct timeval &start)
{
  Delta_Time result;
  
  if(start.tv_sec == end.tv_sec)
    {
      result.secs = 0;
      assert(end.tv_usec >= start.tv_usec);
      result.usecs = end.tv_usec - start.tv_usec;
    }
  else
    {
      assert(end.tv_sec > start.tv_sec);
      result.secs = (end.tv_sec - start.tv_sec) - 1;
      result.usecs = (end.tv_usec + USECS_PER_SEC) - start.tv_usec;
      result.usecs_overflow();
    }

  return result;
}

inline bool operator==(const struct timeval &lhs,
                       const struct timeval &rhs)
{
  return ((lhs.tv_sec == rhs.tv_sec) &&
          (lhs.tv_usec == rhs.tv_usec));
}

inline bool operator<=(const struct timeval &lhs,
                       const struct timeval &rhs)
{
  return ((lhs.tv_sec < rhs.tv_sec) ||
          ((lhs.tv_sec == rhs.tv_sec) &&
           (lhs.tv_usec <= rhs.tv_usec)));
}

inline bool operator<(const struct timeval &lhs,
                       const struct timeval &rhs)
{
  return ((lhs.tv_sec < rhs.tv_sec) ||
          ((lhs.tv_sec == rhs.tv_sec) &&
           (lhs.tv_usec < rhs.tv_usec)));
}

---