Dogcows Code - chaz/yoink/blob - src/Moof/Timer.cc

   1
   2 /*******************************************************************************
   3
   4  Copyright (c) 2009, Charles McGarvey
   5  All rights reserved.
   6
   7  Redistribution   and   use  in  source  and  binary  forms,  with  or  without
   8  modification, are permitted provided that the following conditions are met:
   9
  10    * Redistributions  of  source  code  must retain the above copyright notice,
  11      this list of conditions and the following disclaimer.
  12    * Redistributions  in binary form must reproduce the above copyright notice,
  13      this  list of conditions and the following disclaimer in the documentation
  14      and/or other materials provided with the distribution.
  15
  16  THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23  CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27 *******************************************************************************/
  28
  29 #include <cerrno>
  30 #include <ctime>
  31 #include <limits>
  32
  33 #include <SDL/SDL.h>
  34
  35 #include "Log.hh"
  36 #include "Timer.hh"
  37
  38 #if HAVE_CONFIG_H
  39 #include "config.h"
  40 #endif
  41
  42
  43 namespace Mf {
  44
  45
  46 Scalar Timer::gNextFire = std::numeric_limits<Scalar>::max();
  47 std::map<unsigned,Timer&> Timer::gTimers;
  48
  49
  50 unsigned Timer::getNewID()
  51 {
  52         static unsigned id = 1;
  53         return id++;
  54 }
  55
  56
  57 void Timer::init(const Function& function, Scalar seconds, Mode mode)
  58 {
  59         invalidate();
  60
  61         mMode = mode;
  62
  63         if (mMode != INVALID)
  64         {
  65                 mFunction = function;
  66
  67                 if (mode == ABSOLUTEE)
  68                 {
  69                         mAbsolute = seconds;
  70                 }
  71                 else
  72                 {
  73                         mAbsolute = seconds - getTicks();
  74                         mInterval = seconds;
  75                 }
  76
  77                 mId = getNewID();
  78                 gTimers.insert(std::pair<unsigned,Timer&>(mId, *this));
  79
  80                 if (mAbsolute < gNextFire) gNextFire = mAbsolute;
  81         }
  82 }
  83
  84
  85 bool Timer::isValid() const
  86 {
  87         return mMode != INVALID;
  88 }
  89
  90 void Timer::invalidate()
  91 {
  92         if (mMode != INVALID)
  93         {
  94                 gTimers.erase(mId);
  95                 mMode = INVALID;
  96
  97                 if (isEqual(mAbsolute, gNextFire)) gNextFire = findNextFire();
  98         }
  99 }
 100
 101
 102 void Timer::fire()
 103 {
 104         Scalar t = getTicks();
 105
 106         if (mFunction) mFunction(*this, t);
 107
 108         if (isRepeating())
 109         {
 110                 Scalar absolute = mAbsolute;
 111
 112                 if (isEqual(mAbsolute, t, 1.0)) mAbsolute += mInterval;
 113                 else mAbsolute = mInterval + t;
 114
 115                 if (isEqual(absolute, gNextFire)) gNextFire = findNextFire();
 116         }
 117         else
 118         {
 119                 invalidate();
 120         }
 121 }
 122
 123
 124 Scalar Timer::findNextFire()
 125 {
 126         std::map<unsigned,Timer&>::iterator it;
 127         Scalar nextFire = std::numeric_limits<Scalar>::max();
 128
 129         for (it = gTimers.begin(); it != gTimers.end(); ++it)
 130         {
 131                 Scalar absolute = (*it).second.mAbsolute;
 132                 if (absolute < nextFire) nextFire = absolute;
 133         }
 134
 135         return nextFire;
 136 }
 137
 138
 139 Scalar Timer::getSecondsRemaining() const
 140 {
 141         return mAbsolute - getTicks();
 142 }
 143
 144 bool Timer::isExpired() const
 145 {
 146         return getSecondsRemaining() < 0.0;
 147 }
 148
 149 bool Timer::isRepeating() const
 150 {
 151         return mMode == REPEAT;
 152 }
 153
 154
 155 void Timer::fireIfExpired(Scalar t)
 156 {
 157         std::map<unsigned,Timer&>::iterator it;
 158
 159         if (gNextFire > t) return;
 160
 161         for (it = gTimers.begin(); it != gTimers.end(); ++it)
 162         {
 163                 Timer& timer = (*it).second;
 164                 if (timer.isExpired()) timer.fire();
 165         }
 166 }
 167
 168
 169 #if HAVE_CLOCK_GETTIME
 170
 171 // Since the monotonic clock will provide us with the time since the computer
 172 // started, the number of seconds since that time could easily become so large
 173 // that it cannot be accurately stored in a float (even with as little two days
 174 // uptime), therefore we need to start from a more recent reference (when the
 175 // program starts).  Of course this isn't much of an issue if scalar is a
 176 // double-precision number.
 177
 178 static time_t setReference_()
 179 {
 180         struct timespec ts;
 181
 182         if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0)
 183         {
 184                 return 0;
 185         }
 186
 187         return ts.tv_sec;
 188 }
 189
 190 static const time_t reference = setReference_();
 191
 192
 193 Scalar Timer::getTicks()
 194 {
 195         struct timespec ts;
 196
 197         int result = clock_gettime(CLOCK_MONOTONIC, &ts);
 198         ASSERT(result == 0 && "cannot access clock");
 199
 200         return Scalar(ts.tv_sec - reference) + Scalar(ts.tv_nsec) / 1000000000.0;
 201 }
 202
 203 void Timer::sleep(Scalar seconds, bool absolute)
 204 {
 205         struct timespec ts;
 206         int ret;
 207
 208         if (absolute) seconds -= getTicks();
 209         ts.tv_sec = time_t(seconds);
 210         ts.tv_nsec = long((seconds - Scalar(ts.tv_sec)) * 1000000000.0);
 211
 212         do
 213         {
 214                 ret = nanosleep(&ts, &ts);
 215         }
 216         while (ret == -1 && errno == EINTR);
 217 }
 218
 219
 220 #else // ! HAVE_CLOCK_GETTIME
 221
 222
 223 // If we don't have posix timers, we'll have to use a different timing method.
 224 // SDL only promises centisecond accuracy, but that's better than a kick in the
 225 // butt.
 226
 227 Scalar Timer::getTicks()
 228 {
 229         Uint32 ms = SDL_GetTicks();
 230         return Scalar(ms / 1000) + Scalar(ms % 1000) / 1000.0;
 231 }
 232
 233 void Timer::sleep(Scalar seconds, bool absolute)
 234 {
 235         if (absolute) seconds -= getTicks();
 236         SDL_Delay(Uint32(cml::clamp(int(seconds * 1000.0), 0, 1000)));
 237 }
 238
 239 #endif // HAVE_CLOCK_GETTIME
 240
 241
 242 } // namespace Mf
 243
 244 /** vim: set ts=4 sw=4 tw=80: *************************************************/
 245