src/external/3rd/library/soePlatform/Base/Statistics.h

   1 #ifndef STATISTICS_H
   2 #define STATISTICS_H
   3
   4 #include <time.h>
   5 #include "Platform.h"
   6
   7 namespace Base
   8 {
   9     template <class TYPE, uint32 COUNT>
  10     class CStatistic
  11     {
  12         public:
  13             CStatistic(uint32 freq=0) :
  14                                 mSampleFrequency(freq),
  15                                 mLastSampleTime(0),
  16                                 mSample(0),
  17                                 mSampleTotal(0),
  18                                 mAggregateTotal(0),
  19                                 mAggregateMaximum(0),
  20                                 mAggregateMinimum(0),
  21                                 mAverageTotal(0),
  22                                 mAverageIndex(0),
  23                                 mAverageCount(0)
  24                         {
  25                         }
  26
  27             bool Sample(TYPE value)
  28                         {
  29                                 bool commit = false;
  30
  31                                 if (!mLastSampleTime)
  32                                         mLastSampleTime = time(NULL);
  33
  34                                 if (!mSampleFrequency || mLastSampleTime + mSampleFrequency < (unsigned)time(NULL))
  35                                 {
  36                                         mSampleTotal++;
  37                                         mAggregateTotal += value;
  38                                         if (value > mAggregateMaximum)
  39                                                 mAggregateMaximum = value;
  40                                         if (value < mAggregateMinimum)
  41                                                 mAggregateMinimum = value;
  42
  43                                         if (mAverageIndex == COUNT)
  44                                                 mAverageIndex = 0;
  45                                         if (mAverageCount > COUNT)
  46                                                 mAverageTotal -= mAverageData[mAverageIndex];
  47
  48                                         mAverageData[mAverageIndex++] = value;
  49                                         mAverageTotal += value;
  50
  51                                         if (mAverageCount < COUNT)
  52                                                 mAverageCount++;
  53
  54                                         commit = true;
  55                                         mSample = 0;
  56                                 }
  57
  58                                 mSample += value;
  59
  60                                 return commit;
  61                         }
  62
  63                         TYPE GetSample(uint32 age = 0)
  64                         {
  65                                 if (age > mAverageCount)
  66                                         return 0;
  67
  68                                 uint32 index = mAverageIndex;
  69                                 if (age > index)
  70                                         index = COUNT - (age - index);
  71                                 else
  72                                         index -= age;
  73
  74                                 return mAverageData[index];
  75                         }
  76
  77                         double GetAverage()
  78                         {
  79                                 return (double)mAverageTotal/mAverageCount;
  80                         }
  81
  82                         double GetAggregateAverage()
  83                         {
  84                                 return (double)mAggregateTotal/mSampleTotal;
  85                         }
  86
  87                         TYPE GetMaximum()
  88                         {
  89                                 return mAggregateMaximum;
  90                         }
  91
  92                         TYPE GetMinimum()
  93                         {
  94                                 return mAggregateMinimum;
  95                         }
  96
  97         private:
  98             uint32      mSampleFrequency;
  99                         time_t  mLastSampleTime;
 100                         TYPE    mSample;
 101                         uint32  mSampleTotal;
 102                         TYPE    mAggregateTotal;
 103                         TYPE    mAggregateMaximum;
 104                         TYPE    mAggregateMinimum;
 105
 106                         TYPE    mAverageData[COUNT];
 107                         TYPE    mAverageTotal;
 108             uint32  mAverageIndex;
 109             uint32  mAverageCount;
 110     };
 111
 112     class CStatisticTimer
 113     {
 114         public:
 115             CStatisticTimer(bool running = true);
 116
 117             void Start()    { if (mRunning) return; mStart = getTimer(); mRunning = true; }
 118             void Stop()     { if (!mRunning) return; mTotal += getTimer()-mStart; mRunning = false; }
 119             void Reset()    { mRunning = false; mTotal = 0; }
 120
 121             double  GetTime();
 122             uint64  GetFraction(uint32 fraction=1000);
 123
 124         private:
 125             uint64  mTotal;
 126             uint64  mStart;
 127             bool    mRunning;
 128     };
 129
 130
 131
 132 }
 133 #endif // STATISTICS_H