DepTask.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/Graph/Dep.h"

namespace honey
{

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

    virtual ~DepTask() {}
    
    static DepTask& current();
    
    bool active() const                             { return _state != State::idle; }
    
    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; }
    
    void setId(const Id& id)                        { assert(!_regCount, "Must unregister prior to modifying"); _depNode.setKey(id); }
    const Id& getId() const                         { return _depNode.getKey(); }
    

    DepNode& deps()                                 { assert(!_regCount, "Must unregister prior to modifying"); return _depNode; }

    operator const Id&() const                      { return getId(); }
    
    String info() const;
    
protected:
    enum class State
    {
        idle,           
        queued,         
        depUpWait,      
        exec,           
        depDownWait     
    };
    
    DepTask(const Id& id);

    virtual void exec() = 0;
    virtual void resetFunctor() = 0;
    
    void bindDirty();
    void operator()();
    void finalize_();
    
    virtual void trace(const String& file, int line, const String& msg) const;
    virtual bool traceEnabled() const;

    DepNode             _depNode;
    Mutex               _lock;
    Atomic<State>       _state;
    int                 _regCount;
    DepSched*           _sched;
    WeakPtr<DepTask>    _root;
    int                 _bindId;
    bool                _bindDirty;
    int                 _depUpWaitInit;
    Atomic<int>         _depUpWait;
    int                 _depDownWaitInit;
    Atomic<int>         _depDownWait;
    DepGraph::Vertex*   _vertex;
    bool                _onStack;
    Thread*             _thread;
    int                 _priority;
};

template<class Result>
class DepTask_ : public DepTask
{
public:
    typedef SharedPtr<DepTask_> Ptr;

    template<class Func>
    DepTask_(Func&& f, const Id& id = idnull)       : DepTask(id), _func(forward<Func>(f)) {}


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

    static DepTask_& current()                      { return static_cast<DepTask_&>(DepTask::current()); }

private:
    virtual void exec()                             { _func.invoke_delayedReady(); }
    virtual void resetFunctor()                     { _func.setReady(true); }

    PackagedTask<Result ()> _func;
};


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

    bool reg(DepTask& task);
    bool unreg(DepTask& task);


    bool enqueue(DepTask& task);
    
    static bool trace;
    
private:
    void bind(DepTask& root);    
    bool enqueue_priv(DepTask& task);
    
    SharedPtr<thread::Pool> _pool;
    Mutex                   _lock;
    vector<DepTask*>        _taskStack;
    DepTask::DepGraph       _depGraph;
    int                     _bindId;
};

inline bool DepTask::traceEnabled() const           { return DepSched::trace; }

}