thread.h

Go to the documentation of this file.

 
#pragma once
 
#include <thread>
#include <promeki/core/objectbase.h>
#include <promeki/core/set.h>
#include <promeki/core/mutex.h>
#include <promeki/core/waitcondition.h>
#include <promeki/core/atomic.h>
 
PROMEKI_NAMESPACE_BEGIN
 
enum class SchedulePolicy {
        Default,        
        RoundRobin,     
        Fifo,           
        Batch,          
        Idle            
};
 
class Thread : public ObjectBase {
        PROMEKI_OBJECT(Thread, ObjectBase)
        public:
                using NativeHandle = std::thread::native_handle_type;
                static Thread *adoptCurrentThread();
 
                static Thread *currentThread();
 
                static uint64_t currentNativeId();
 
                static int priorityMin(SchedulePolicy policy = SchedulePolicy::Default);
 
                static int priorityMax(SchedulePolicy policy = SchedulePolicy::Default);
 
                static unsigned int idealThreadCount();
 
                Thread(ObjectBase *parent = nullptr);
 
                virtual ~Thread();
 
                void start(size_t stackSize = 0);
 
                Error wait(unsigned int timeoutMs = 0);
 
                EventLoop *threadEventLoop() const;
 
                void quit(int returnCode = 0);
 
                int exitCode() const { return _exitCode.value(); }
 
                bool isRunning() const { return _running.value(); }
 
                bool isAdopted() const { return _adopted; }
 
                bool isCurrentThread() const { return _currentThread == this; }
 
                uint64_t nativeId() const { return _nativeId.value(); }
 
                SchedulePolicy schedulePolicy() const;
 
                int priority() const;
 
                Error setPriority(int priority,
                                  SchedulePolicy policy = SchedulePolicy::Default);
 
                String name() const;
 
                void setName(const String &name);
 
                Set<int> affinity() const;
 
                Error setAffinity(const Set<int> &cpus);
 
                PROMEKI_SIGNAL(started);
 
                PROMEKI_SIGNAL(finished, int);
 
        protected:
                virtual void run();
 
        private:
                static thread_local Thread      *_currentThread;
 
                std::thread             _thread;
                Atomic<bool>            _running;
                Atomic<int>             _exitCode;
                Atomic<uint64_t>        _nativeId;
                String                  _name;
                EventLoop               *_threadLoop = nullptr;
                mutable Mutex           _mutex;
                WaitCondition           _startedCv;
                WaitCondition           _finishedCv;
                bool                    _started = false;
                bool                    _finished = false;
                bool                    _adopted = false;
                bool                    _usesPthread = false;
                NativeHandle _pthreadHandle{};
 
                NativeHandle nativeHandle() const;
                bool isJoinable() const;
                void joinThread();
                void applyOsName();
                void threadEntry();
};
 
PROMEKI_NAMESPACE_END