ReposStats.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

// ReposStats.H - data structures representing statistics about the
// rpeository

// Last modified on Sat Jan  8 20:38:52 EST 2005 by ken@xorian.net

#ifndef REPOSSTATS_H
#define REPOSSTATS_H 1

#include <Basics.H>
#include <SRPC.H>

#define USECS_PER_SEC 1000000

namespace ReposStats
{
  enum StatKind
    {
      // 0 can be used when there is no StatKind available.
      invalid = 0,

      // Statistics about the file descriptor cache.
      fdCache,

      // These statistics are across all NFS/SRPC procedures.  At some
      // point in the future, there may also be statistics that are
      // split up by invidual procedure.
      dupeTotal,
      srpcTotal,
      nfsTotal,

      // Repository server memory usage
      memUsage,

      // Final enum elemnt is used as a marker of the end of allowable
      // statistics.
      statKindEnd
    };

  class Stat
  {
  public:
    virtual void send(SRPC *srpc) const throw (SRPC::failure) = 0;
    virtual void recv(SRPC *srpc) throw (SRPC::failure) = 0;
  };

  // Statistics for the file descriptor cache.
  class FdCacheStats : public Stat
  {
  public:
    Basics::uint32 n_in_cache;
    Basics::uint64 hits;
    Basics::uint64 open_misses;
    Basics::uint64 try_misses;
    Basics::uint64 evictions;
    Basics::uint64 expirations;

    FdCacheStats()
      : n_in_cache(0), hits(0), open_misses(0), try_misses(0),
        evictions(0), expirations(0)
    { }
    FdCacheStats(const FdCacheStats &other)
      : n_in_cache(other.n_in_cache), hits(other.hits),
        open_misses(other.open_misses), try_misses(other.try_misses),
        evictions(other.evictions), expirations(other.expirations)
    { }
    // No destructor needed
    FdCacheStats& operator=(const FdCacheStats &other)
    {
      n_in_cache = other.n_in_cache;
      hits = other.hits;
      open_misses = other.open_misses;
      try_misses = other.try_misses;
      evictions = other.evictions;
      expirations = other.expirations;
      return *this;
    }

    // Allow for subtraction to compute differences in a time
    // interval.
    inline FdCacheStats operator-(const FdCacheStats &other) const
    {
      FdCacheStats result;
      // Note: we just pass on our n_in_cache, as it's not a
      // cumulative count over the life of the repository.
      result.n_in_cache  = n_in_cache;
      result.hits        = hits        - other.hits;
      result.open_misses = open_misses - other.open_misses;
      result.try_misses  = try_misses  - other.try_misses;
      result.evictions   = evictions   - other.evictions;
      result.expirations = expirations - other.expirations;
      return result;
    }

    void send(SRPC *srpc) const throw (SRPC::failure);
    void recv(SRPC *srpc) throw (SRPC::failure);
  };

  // Statistics about duplicate suppression.
  class DupeStats : public Stat
  {
  public:
    Basics::uint64 non, inProcess, completed;
    DupeStats()
      : non(0), inProcess(0), completed(0)
    { }
    DupeStats(const DupeStats &other)
      : non(other.non), inProcess(other.inProcess), completed(other.completed)
    { }
    // No destructor needed
    DupeStats &operator=(const DupeStats &other)
    {
      non = other.non;
      inProcess = other.inProcess;
      completed = other.completed;
      return *this;
    }

    inline Basics::uint64 total() const
    {
      return non+inProcess+completed;
    }
    inline void zero()
    {
      non = 0;
      inProcess = 0;
      completed = 0;
    }
    inline DupeStats &operator+=(const DupeStats &other)
    {
      non += other.non;
      inProcess += other.inProcess;
      completed += other.completed;
      return *this;
    }
    inline DupeStats operator-(const DupeStats &other) const
    {
      DupeStats result;
      result.non = non - other.non;
      result.inProcess = inProcess - other.inProcess;
      result.completed = completed - other.completed;
      return result;
    }

    void send(SRPC *srpc) const throw (SRPC::failure);
    void recv(SRPC *srpc) throw (SRPC::failure);
  };

  // This class is used to represent statistics for both SRPC calls
  // and NFS calls.
  class TimedCalls : public Stat
  {
  public:
    // Number of calls completed
    Basics::uint64 call_count;
    // Elapsed time over all calls
    Basics::uint64 elapsed_secs;
    Basics::uint32 elapsed_usecs;

    TimedCalls()
      : call_count(0), elapsed_secs(0), elapsed_usecs(0)
    { }
    TimedCalls(const TimedCalls &other)
      : call_count(other.call_count),
        elapsed_secs(other.elapsed_secs),
        elapsed_usecs(other.elapsed_usecs)
    { }
    TimedCalls &operator=(const TimedCalls &other)
    {
      call_count = other.call_count;
      elapsed_secs = other.elapsed_secs;
      elapsed_usecs = other.elapsed_usecs;
      return *this;
    }

    inline TimedCalls operator-(const TimedCalls &other) const
    {
      TimedCalls result;
      result.call_count = call_count - other.call_count;
      if(elapsed_secs == other.elapsed_secs)
        {
          result.elapsed_secs = 0;
          assert(elapsed_usecs >= other.elapsed_usecs);
          result.elapsed_usecs = elapsed_usecs - other.elapsed_usecs;
        }
      else
        {
          assert(elapsed_secs > other.elapsed_secs);
          result.elapsed_secs = (elapsed_secs - other.elapsed_secs) - 1;
          result.elapsed_usecs = ((elapsed_usecs + USECS_PER_SEC) -
                                  other.elapsed_usecs);
          if(result.elapsed_usecs > USECS_PER_SEC)
            {
              result.elapsed_secs += result.elapsed_usecs/USECS_PER_SEC;
              result.elapsed_usecs %= USECS_PER_SEC;
            }
        }
      return result;
    }

    void send(SRPC *srpc) const throw (SRPC::failure);
    void recv(SRPC *srpc) throw (SRPC::failure);
  };

  class MemStats : public Stat
  {
  public:
    Basics::uint64 total, resident;
    MemStats()
      : total(0), resident(0)
    { }
    MemStats(Basics::uint64 t, Basics::uint64 r)
      : total(t), resident(r)
    { }
    MemStats(const MemStats &other)
      : total(other.total), resident(other.resident)
    { }
    // No destructor needed
    MemStats &operator=(const MemStats &other)
    {
      total = other.total;
      resident = other.resident;
      return *this;
    }

    void send(SRPC *srpc) const throw (SRPC::failure);
    void recv(SRPC *srpc) throw (SRPC::failure);
  };

}

#endif // REPOSSTATS_H

---