dali/internal/system/common/frame-time-stats.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // STRUCT HEADER
  19 #include <dali/internal/system/common/frame-time-stats.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <cmath>
  23
  24 namespace Dali
  25 {
  26 namespace Internal
  27 {
  28 namespace Adaptor
  29 {
  30 namespace
  31 {
  32 const float EPSILON                          = 0.9f;            // rolling average = (average * epsilon) + (current * epsilon)
  33 const float ONE_OVER_MICROSECONDS_TO_SECONDS = 1.f / 1000000.f; ///< microseconds per second
  34 } // namespace
  35
  36 FrameTimeStats::FrameTimeStats()
  37 : mTotal(0.f)
  38 {
  39   mSamples.Reserve(16); // Fill out a little to avoid early reallocations
  40
  41   Reset();
  42 }
  43
  44 FrameTimeStats::~FrameTimeStats()
  45 {
  46 }
  47
  48 void FrameTimeStats::StartTime(const FrameTimeStamp& timeStamp)
  49 {
  50   // check to make sure we don't get 2 start times in a row
  51   if(mTimeState != WAITING_FOR_START_TIME)
  52   {
  53     Reset();
  54   }
  55
  56   mStart     = timeStamp;
  57   mTimeState = WAITING_FOR_END_TIME;
  58 }
  59
  60 void FrameTimeStats::EndTime(const FrameTimeStamp& timeStamp)
  61 {
  62   if(mTimeState != WAITING_FOR_END_TIME)
  63   {
  64     Reset();
  65     return;
  66   }
  67
  68   mTimeState = WAITING_FOR_START_TIME;
  69   mRunCount++;
  70
  71   // frame time in seconds
  72   unsigned int elapsedTime = FrameTimeStamp::MicrosecondDiff(mStart, timeStamp);
  73
  74   mSamples.PushBack(elapsedTime);
  75
  76   // if the min and max times haven't been set, do that now.
  77   if(!mMinMaxTimeSet)
  78   {
  79     mMin           = elapsedTime;
  80     mMax           = elapsedTime;
  81     mMinMaxTimeSet = true;
  82   }
  83   else
  84   {
  85     if(elapsedTime < mMin)
  86     {
  87       mMin = elapsedTime;
  88     }
  89     else if(elapsedTime > mMax)
  90     {
  91       mMax = elapsedTime;
  92     }
  93   }
  94
  95   mTotal += elapsedTime;
  96 }
  97
  98 void FrameTimeStats::Reset()
  99 {
 100   mTimeState     = WAITING_FOR_START_TIME;
 101   mMinMaxTimeSet = false;
 102   mMin           = 0.f;
 103   mMax           = 0.f;
 104   mRunCount      = 0;
 105   mStart         = FrameTimeStamp();
 106   mSamples.Clear();
 107 }
 108
 109 float FrameTimeStats::GetMaxTime() const
 110 {
 111   return mMax * ONE_OVER_MICROSECONDS_TO_SECONDS;
 112 }
 113
 114 float FrameTimeStats::GetMinTime() const
 115 {
 116   return mMin * ONE_OVER_MICROSECONDS_TO_SECONDS;
 117 }
 118
 119 float FrameTimeStats::GetTotalTime() const
 120 {
 121   return mTotal * ONE_OVER_MICROSECONDS_TO_SECONDS;
 122 }
 123
 124 unsigned int FrameTimeStats::GetRunCount() const
 125 {
 126   return mRunCount;
 127 }
 128
 129 void FrameTimeStats::CalculateMean(float& meanOut, float& standardDeviationOut) const
 130 {
 131   if(mSamples.Size() > 0)
 132   {
 133     // Mean
 134     unsigned int sum = 0;
 135     for(Samples::ConstIterator it = mSamples.Begin(), itEnd = mSamples.End(); it != itEnd; ++it)
 136     {
 137       unsigned int value = *it;
 138
 139       sum += value;
 140     }
 141
 142     meanOut = static_cast<float>(sum) / mSamples.Size();
 143
 144     // Variance
 145     float variance = 0.0f;
 146     for(Samples::ConstIterator it = mSamples.Begin(), itEnd = mSamples.End(); it != itEnd; ++it)
 147     {
 148       unsigned int value = *it;
 149
 150       float difference = static_cast<float>(value) - meanOut;
 151
 152       variance += difference * difference;
 153     }
 154
 155     variance /= mSamples.Size();
 156
 157     // Standard deviation
 158     standardDeviationOut = sqrtf(variance);
 159
 160     meanOut *= ONE_OVER_MICROSECONDS_TO_SECONDS;
 161     standardDeviationOut *= ONE_OVER_MICROSECONDS_TO_SECONDS;
 162   }
 163   else
 164   {
 165     meanOut              = 0.0f;
 166     standardDeviationOut = 0.0f;
 167   }
 168 }
 169
 170 } // namespace Adaptor
 171
 172 } // namespace Internal
 173
 174 } // namespace Dali