Thread.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/Misc/Exception.h"
#include "Honey/Chrono/Clock.h"
#include "Honey/Thread/platform/Thread.h"

namespace honey
{

class Thread;
class Condition;
class Mutex;

namespace thread
{
    namespace priv
    {
        struct StoreId
        {
            StoreId(int id = -1)                    : id(id), reclaim(0) {}
            int id;
            int reclaim;
        };

        struct Store
        {
            Store()                                 : ptr(nullptr), reclaim(-1), fin(bind(finalize<void>(), ptr)) {}
            void* ptr;
            int reclaim;
            function<void ()> fin;
        };

        class InterruptWait : mt::NoCopy
        {
        public:
            InterruptWait(Thread& thread, Condition& cond, Mutex& mutex);
            ~InterruptWait();
        private:
            Thread& thread;
        };
    }
    namespace current
    {
        inline void yield()                         { platform::yield(); }
        inline void pause()                         { platform::pause(); }
        void sleep(MonoClock::Duration time);
        void sleep(MonoClock::TimePoint time);
        inline void spin(int count)                 { for (int i = 0; i < count; ++i) pause(); }
        bool interruptEnabled();
        void interruptPoint();
    }

    template<class T>
    class Local
    {
    public:
        typedef function<T* ()> Init;
        typedef function<void (T*)> Fin;

        Local(const Init& init = []{ return new T(); }, const Fin& fin = finalize<T>());
        ~Local();

        Local& operator=(const T& rhs)              { get() = rhs; return *this; }

        operator const T&() const                   { return get(); }
        operator T&()                               { return get(); }
        const T* operator->() const                 { return &get(); }
        T* operator->()                             { return &get(); }
        const T& operator*() const                  { return get(); }
        T& operator*()                              { return get(); }

        const T& get() const                        { const_cast<Local*>(this)->get(); }

        T& get();

    private:
        priv::StoreId _id;
        Init _init;
        Fin _fin;
    };

    struct Interrupted : Exception                  { EXCEPTION(Interrupted) };


    struct InterruptEnable : mt::NoCopy
    {
        InterruptEnable(bool enable);
        ~InterruptEnable();
    private:
        Thread& thread;
        bool saveState;
    };
}


class ConditionLock;
class SpinLock;

class Thread : platform::Thread, mt::NoCopy
{
    typedef platform::Thread Super;
    friend class platform::Thread;
    friend void thread::current::sleep(MonoClock::TimePoint time);
    friend bool thread::current::interruptEnabled();
    friend void thread::current::interruptPoint();
    template<class T> friend class thread::Local;
    friend struct thread::InterruptEnable;
    friend class thread::priv::InterruptWait;

public:
    typedef Super::ThreadId ThreadId;
    typedef function<void ()> Entry;


    Thread(const Entry& entry, int stackSize = 0);
    Thread(Thread&& rhs) noexcept;
    virtual ~Thread();

    Thread& operator=(Thread&& rhs);

    static Thread& current()                        { return static_cast<Thread&>(Super::current()); }

    void start();

    void join()                                     { join(MonoClock::TimePoint::max()); }
    bool join(MonoClock::Duration time)             { return join(time == time.max() ? MonoClock::TimePoint::max() : MonoClock::now() + time); }
    bool join(MonoClock::TimePoint time);


    void interrupt(const Exception::ConstPtr& e = new thread::Interrupted);
    bool interruptRequested() const;

    static int priorityNormal()                     { return Super::priorityNormal(); }
    static int priorityMin()                        { return Super::priorityMin(); }
    static int priorityMax()                        { return Super::priorityMax(); }

    void setPriority(int priority)                  { Super::setPriority(priority); }
    int getPriority() const                         { return Super::getPriority(); }

    static const ThreadId threadIdInvalid;
    ThreadId threadId() const                       { return Super::threadId(); }

    static int concurrency()                        { return Super::concurrency(); }

private:
    typedef thread::priv::StoreId StoreId;
    typedef thread::priv::Store Store;

    Thread(bool external, int stackSize);
    void finalize();

    void entry();

    static StoreId allocStore();
    static void freeStore(StoreId id);
    Store& store(const StoreId& id)                 { const_cast<Thread*>(this)->expandStore(id.id); return _stores[id.id]; } 
    void expandStore(int id)                        { if (id < (int)_stores.size()) return; _stores.resize(id*2+1); }

    Entry                       _entry;
    UniquePtr<SpinLock>         _lock;
    bool                        _started;
    bool                        _done;
    UniquePtr<ConditionLock>    _doneCond;
    UniquePtr<ConditionLock>    _sleepCond;

    bool                        _interruptEnable;
    Exception::ConstPtr         _interruptEx;
    Condition*                  _interruptCond;
    Mutex*                      _interruptMutex;

    vector<Store>               _stores;

    struct Static
    {
        Static();
        ~Static();

        vector<StoreId>         storeIds;
        int                     storeCount;
        UniquePtr<SpinLock>     storeLock;
    };
    static mt_global(Static, getStatic,);
};


namespace thread
{
    template<class T>
    Local<T>::Local(const Init& init, const Fin& fin)   : _id(Thread::allocStore()), _init(init), _fin(fin) {}
    
    template<class T>
    Local<T>::~Local()                              { Thread::freeStore(_id); }
    
    template<class T>
    T& Local<T>::get()
    {
        priv::Store& store = Thread::current().store(_id);
        //This thread may not have init the ptr yet, or the ptr could be from an old local that has been deleted
        if (store.reclaim != _id.reclaim)
        {
            store.fin();
            store.reclaim = _id.reclaim;
            T* ptr = _init();
            store.ptr = ptr;
            //store.fin = std::bind(_fin, ptr); //TODO: clang bug, uncomment to properly destroy thread locals
            store.fin = std::bind(finalize<T>(), ptr);
        }
        return *reinterpret_cast<T*>(store.ptr);
    }
}

}