PeriodicTask.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Thread/Future/Util.h"
#include "Honey/Thread/LockFree/Queue.h"

namespace honey
{

class PeriodicTask;
class PeriodicSched;
//for shared ptr member var, is_base_of needs a defined class
namespace mt { template<> struct is_base_of<honey::priv::SharedObj_tag, PeriodicTask> : std::true_type {}; }
class PeriodicTask : public SharedObj<PeriodicTask>, thread::Pool::Task
{
    friend class PeriodicSched;
    friend struct mt::Funcptr<void ()>;
    
public:
    typedef SharedPtr<PeriodicTask> Ptr;
    typedef function<void ()> Func;

    struct Cancelled : Exception                    { EXCEPTION(Cancelled) };
    
    virtual ~PeriodicTask() {}
    
    static PeriodicTask& current();
    
    bool active() const                             { return _state != State::idle; }
    MonoClock::Duration delay() const               { return _due.load() - MonoClock::now(); }
    
    void cancel();
    void interrupt(const Exception::ConstPtr& e = new thread::Interrupted)   { Mutex::Scoped _(_lock); if (_thread) _thread->interrupt(e); }
    bool interruptRequested()                       { Mutex::Scoped _(_lock); return _thread ? _thread->interruptRequested() : false; }
    
    void setPriority(int priority)                  { Mutex::Scoped _(_lock); _priority = priority; if (_thread) _thread->setPriority(_priority); }
    int getPriority() const                         { return _priority; }
    
    const Id& id() const                            { return _id; }
    String info() const;
    
protected:
    enum class State
    {
        idle,           
        wait,           
        exec            
    };
    
    PeriodicTask(PeriodicSched& sched, optional<MonoClock::Duration> period, optional<MonoClock::Duration> delay, const Id& id);

    virtual void exec() = 0;
    virtual void readyFunctor(bool reset) = 0;
    virtual void cancelFunctor() = 0;
    
    void operator()();
    
    virtual void trace(const String& file, int line, const String& msg) const;
    virtual bool traceEnabled() const;

    PeriodicSched&                      _sched;
    optional<MonoClock::Duration>       _period;
    optional<MonoClock::Duration>       _delay;
    Id                                  _id;
    Mutex                               _lock;
    Ptr                                 _self;
    Atomic<State>                       _state;
    Atomic<MonoClock::TimePoint>        _due;
    bool                                _cancelled;
    Thread*                             _thread;
    int                                 _priority;
};

template<class Result>
class PeriodicTask_ : public PeriodicTask
{
    friend class PeriodicSched;

public:
    typedef SharedPtr<PeriodicTask_> Ptr;


    Future<Result> future()                         { return _func.future(); }

    static PeriodicTask_& current()                 { return static_cast<PeriodicTask_&>(PeriodicTask::current()); }

private:
    template<class Func>
    PeriodicTask_(PeriodicSched& sched, Func&& f, optional<MonoClock::Duration> period, optional<MonoClock::Duration> delay, const Id& id)
                                                    : PeriodicTask(sched, period, delay, id), _func(forward<Func>(f)) {}
    
    virtual void exec()                             { _func.invoke_delayedReady(); }
    virtual void readyFunctor(bool reset)           { _func.setReady(reset); }
    virtual void cancelFunctor()                    { _func.setFunc([]{ throw_ Cancelled(); }); _func(); }
    
    PackagedTask<Result ()> _func;
};

class PeriodicSched
{
    friend class PeriodicTask;
    
public:
    static mt_global(PeriodicSched, inst, (future::AsyncSched::inst()));
    
    PeriodicSched(thread::Pool& pool);

    ~PeriodicSched();
    

    template<class Func, class PeriodicTask_ = PeriodicTask_<typename std::result_of<Func()>::type>>
    typename PeriodicTask_::Ptr schedule(   Func&& f, optional<MonoClock::Duration> period = optnull,
                                            optional<MonoClock::Duration> delay = optnull, const Id& id = idnull)
    {
        typename PeriodicTask_::Ptr task(new PeriodicTask_(*this, forward<Func>(f), period, delay, id));
        add(*task);
        return task;
    }
    
    static bool trace;
    
private:
    enum class Action
    {
        add,
        remove
    };
    
    void add(PeriodicTask& task);
    void remove(PeriodicTask& task);
    
    void run();
    
    SharedPtr<thread::Pool>                             _pool;
    Thread                                              _thread;
    bool                                                _active;
    ConditionLock                                       _cond;
    bool                                                _condWait;
    SpinLock                                            _condOne;
    multimap<MonoClock::TimePoint, PeriodicTask::Ptr>   _tasks;
    vector<PeriodicTask::Ptr>                           _due;
    lockfree::Queue<tuple<Action, PeriodicTask::Ptr>>   _actions;
};

inline bool PeriodicTask::traceEnabled() const      { return PeriodicSched::trace; }

}