Timing.h

Go to the documentation of this file.

#ifndef __LDK_TIMING_HH__
#define __LDK_TIMING_HH__

//   Copyright (C) 2003-2006 Lorien Dunn.
//
//   Contact: loriendunn AT users DOT sourceforge DOT net
//
//   This software is provided 'as-is', without any express or implied warranty.
//   In no event will the authors be held liable for any damages arising from
//   the use of this software.
//
//   Permission is granted to anyone to use this software for any purpose,
//   including commercial applications, and to alter it and redistribute it
//   freely, subject to the following restrictions:
//
//   1. The origin of this software must not be misrepresented; you must not
//   claim that you wrote the original software. If you use this software in a
//   product, an acknowledgment in the product documentation would be
//   appreciated but is not required.
//
//   2. Altered source versions must be plainly marked as such, and must not be
//   misrepresented as being the original software.
//
//   3. This notice may not be removed or altered from any source distribution.
//


#include "LDK/Types.h"
#include "LDK/Memory.h"
#include "LDK/SmartPointers.h"
#include <list>



namespace LDK
{


LDK_API uint64 time();


class Timer : public Object
{
private:
    bool mPaused;
    uint64 mCurrentTick;
    uint64 mLastTickTime;
    uint32 mTickDur;
public:

    inline Timer(uint32 tickDuration=1)
    : mPaused(false)
    , mCurrentTick(0)
    , mLastTickTime(LDK::time())
    , mTickDur(tickDuration)
    {
        assert(tickDuration);
    }

    inline uint32 tickDuration() const { return mTickDur; }
    inline void tickDuration(uint32 duration)
    {
        assert(duration);
        mTickDur = duration;
    }

    inline uint64 time()
    {
        uint32 timeDiff = (uint32) (LDK::time() - mLastTickTime);
        if(!mPaused && timeDiff >= mTickDur)
        {
            mCurrentTick += timeDiff / mTickDur;
        }
        return mCurrentTick;
    }

    inline void pause()
    {
        assert(!mPaused);
        mPaused = true;
    }
    inline void unpause()
    {
        assert(mPaused);
        uint64 time = LDK::time();
        if(time - mLastTickTime >= mTickDur)
            mCurrentTick++;
        mLastTickTime = time;
        mPaused = false;
    }
    inline bool isPaused() { return mPaused; }
};
typedef IntrusiveSmartPointer<Timer> SmartTimer;

//just to make the compiler complain if you try passing a date as an ID :)
//NB empty structs are part of the C++ standard
struct TaskID_T {};
typedef TaskID_T* TaskID;

class LDK_API Task
{
public:
    virtual ~Task() {}
    virtual void execute(TaskID id, uint64 dueDate, uint32 latency) = 0;
};

class TaskData;
class LDK_API Scheduler
{
private:

    SmartTimer mTimer;
    typedef std::list<TaskData*,Allocator<TaskData*> > TaskList;
    TaskList* mTable;
    size_t mTableSize;
    uint64 mLastExecTime;
    uint64 mActiveTaskFlag;
    bool mCanPause;

    friend class TaskData;

public:
    Scheduler(SmartTimer timer=NULL, size_t tableSize=5000);
    ~Scheduler();

    inline SmartTimer timer() { return mTimer; }
    inline uint64 time() { return mTimer->time(); }
    inline uint64 frameTime() { return mLastExecTime; }

    inline void pause() { mTimer->pause(); }
    inline void unpause() { mTimer->unpause(); }
    inline bool isPaused() { return mTimer->isPaused(); }

    TaskID absolute(uint64 when, Task* task);
    void repeatAbsolute(TaskID id, uint64 when);
    inline TaskID relative(uint64 when, Task* task) { return absolute(time()+when,task); }
    void repeatRelative(TaskID id, uint64 when);

    void cancel(TaskID id);
    void execute(uint64 time=0);
    void clear();
};


class LDK_API SystemScheduler : public Singleton<Scheduler>
{
private:

    SystemScheduler() {}
    SystemScheduler(const SystemScheduler&) {}
    ~SystemScheduler() {}
    void operator=(const SystemScheduler&) {}

public:
    //called internally. Do not touch.
    static void initialise();

    inline static SmartTimer timer() { return instance().timer(); }
    inline static uint64 time() { return instance().time(); }
    inline static uint64 frameTime(){ return instance().frameTime(); }

    inline static void pause() { instance().pause(); }
    inline static void unpause() { instance().unpause(); }
    inline static bool isPaused() { return instance().isPaused(); }

    inline static TaskID absolute(uint64 when, Task* task)
    {
        return instance().absolute(when,task);
    }

    inline static TaskID relative(uint64 when, Task* task)
    {
        return instance().relative(when, task);
    }

    inline static void repeatAbsolute(TaskID id, uint64 when)
    {
        instance().repeatAbsolute(id, when);
    }

    inline static void repeatRelative(TaskID id, uint64 when)
    {
        instance().repeatRelative(id, when);
    }

    inline static void cancel(TaskID id) { instance().cancel(id); }

    inline static void execute() { instance().execute(); }

    inline static void clear() { instance().clear(); }
};


class LDK_API Ticker
{
protected:

    bool mRunning;
    Scheduler& mScheduler;
    uint32 mTickDur;
    bool mStrictTiming;
    TaskID mID;
    uint64 mCurrentTick;
    class LDK_API Tick;
    Tick* mTick;

    class LDK_API Tick : public Task
    {
    private:

        Ticker& mTicker;

    public:

        inline Tick(Ticker& ticker)
        : mTicker(ticker)
        {
        }

        virtual void execute(TaskID id, uint64 dueDate, uint32 latency)
        {
            if(mTicker.mRunning)
            {
                mTicker.tick();
                mTicker.mCurrentTick++;
                if(mTicker.mStrictTiming)
                    mTicker.mScheduler.repeatAbsolute(id,dueDate+mTicker.mTickDur);
                else
                    mTicker.mScheduler.repeatRelative(id,mTicker.mTickDur);
                return;
            }
            mTicker.mTick = NULL;
        }
    };

    friend class LDK_API Tick;

public:

    inline Ticker(Scheduler& sched, uint32 tickDuration, bool strictTiming=true)
    : mRunning(false)
    , mScheduler(sched)
    , mTickDur(tickDuration)
    , mStrictTiming(strictTiming)
    , mCurrentTick(0)
    {
        assert(mTickDur);
    }

    virtual ~Ticker() throw()
    {
        if(mTick)
            LDK::destroy<Tick>(mTick);
        mRunning = false;
    }

    virtual void tick() {}

    inline void start()
    {
        assert(!mRunning);
        if(!mTick)
            mTick = LDK_CREATE1(Tick,*this);
        mScheduler.relative(0,mTick);
    }

    inline void stop()
    {
        assert(mTick);
        assert(mRunning);
        mRunning = false;
        mCurrentTick = 0;
    }

    inline void pause()
    {
        assert(mTick);
        assert(mRunning);
        mRunning = false;
    }

    inline void unpause()
    {
        assert(!mTick);
        assert(!mRunning);
        mRunning = true;
        mScheduler.relative(1,mTick);
    }

    inline uint32 tickDuration() const { return mTickDur; }

    inline void tickDuration(uint32 duration)
    {
        assert(duration);
        mTickDur = duration;
    }

    inline uint64 currentTick() const { return mCurrentTick; }
};


}//namespace LDK





#endif //__LDK_TIMING_HH__

---