Thread.h

Go to the documentation of this file.

#pragma once
#include <misc/gen/Condition.h>
#include <misc/gen/Exception.h>
#include <misc/gen/Mutex.h>
#include <misc/gen/TClosure.h>
#include <misc/gen/TimeSpec.h>
#include <misc/gen/target.h>
#include <misc/global.h>
#include <pthread.h>
#include <string>
#include <unistd.h>
#include <utility>
#if IS_WIN
  #include <windows.h>
#else
  #include <sys/eventfd.h>
#endif
 
namespace sf
{
 
class _MISC_CLASS Thread
{
  public:
    typedef pthread_t handle_type;
 
#if IS_WIN
    typedef DWORD id_type;
#else
    typedef pid_t id_type;
#endif
 
    enum EStatus : int
    {
      tsInvalid = 0,
      tsCreated,
      tsRunning,
      tsFinished,
      tsTerminated
    };
 
    class Attributes
    {
      public:
        typedef ::pthread_attr_t* handle_type;
 
        Attributes();
 
        Attributes(const Attributes&) = delete;
 
        Attributes& operator=(const Attributes&) = delete;
 
        explicit Attributes(Thread::handle_type th);
 
        ~Attributes();
 
        void setup(Thread::handle_type th = 0);
 
        [[nodiscard]] size_t getStackSize() const;
 
        void setStackSize(size_t sz);
 
        enum ESchedulePolicy : int
        {
          spScheduleOther = SCHED_OTHER,
          spScheduleFifo = SCHED_FIFO,
          spScheduleRoundRobin = SCHED_RR,
#if IS_WIN
          spScheduleBatch = spScheduleOther,
          spScheduleIdle = spScheduleOther,
          spScheduleResetOnFork = spScheduleOther
#else
          spScheduleBatch = SCHED_BATCH,
          spScheduleIdle = SCHED_IDLE,
          spScheduleResetOnFork = SCHED_RESET_ON_FORK
#endif
        };
 
        void setSchedulePolicy(ESchedulePolicy policy);
 
        [[nodiscard]] ESchedulePolicy getSchedulePolicy() const;
 
        inline operator handle_type() const;
 
      private:
        handle_type _attributes;
    };
 
    handle_type start();
 
    handle_type start(const Attributes& attr);
 
    virtual void terminate();
 
    void terminateAndWait();
 
    void waitForExit();
 
    [[nodiscard]] EStatus getStatus() const;
 
    [[nodiscard]] const char* getStatusText(EStatus status = (EStatus) -1) const;
 
    [[nodiscard]] int getExitCode() const;
 
    [[nodiscard]] bool isSelf() const;
 
    [[nodiscard]] id_type getId() const;
 
    [[nodiscard]] handle_type getHandle() const;
 
    static int getTerminationSignal();
 
    inline operator handle_type() const;
 
    enum EPriority : int
    {
      tpIdle = -15,
      tpLowest = -2,
      tpBelowNormal = -1,
      tpNormal = 0,
      tpAboveNormal = 1,
      tpHighest = 2,
      tpTimeCritical = 15
    };
 
    void setName(const char* name);
 
    std::string getName() const;
 
    [[nodiscard]] int getPriority() const;
 
    bool setPriority(int pri, int sp = Attributes::spScheduleOther);
 
    void setTerminationTime(const TimeSpec& ts);
 
    [[nodiscard]] bool shouldTerminate() const;
 
    void exit(int code);
 
    inline void setDebug(bool yn);
 
    static bool yieldToOther();
 
    class ThreadException : public ExceptionBase<ThreadException>
    {
      public:
        explicit ThreadException(const char* message) noexcept
          : ExceptionBase()
        {
          formatMessage(message);
        }
 
        template<typename... Args>
        explicit ThreadException(const char* format, Args&&... args) noexcept
          : ExceptionBase()
        {
          formatMessage(format, args...);
        }
    };
 
    class TerminateException : public ThreadException
    {
      public:
        explicit TerminateException(const std::string& from)
          : ThreadException("Terminating from %s", from.c_str())
        {}
    };
 
    bool sleep(const TimeSpec& ts, bool alertable = true) const;
 
    static handle_type getCurrentHandle();
 
    static id_type getMainId();
 
    static id_type getCurrentId();
 
    static Thread& getCurrent();
 
    static size_t getCurrentStackSize();
 
    Thread(const Thread&) = delete;
 
    const Thread& operator=(const Thread&) = delete;
 
    [[nodiscard]] inline bool isDebug() const;
 
  protected:
    Thread(const std::string& name);
 
    Thread(bool);
 
    virtual ~Thread();
 
    virtual void cleanup();
 
  protected:
    virtual int run() = 0;
 
    void TerminationSignal();
 
  private:
    int create();
 
    void setConditionWaiting(Condition* condition);
 
    std::string _name;
    Mutex _mutex{"thread"};
    pid_t _threadId{0};
    handle_type _handle{0};
    EStatus _status{EStatus::tsInvalid};
    bool _terminationRequested{false};
    TimeSpec _terminationTime{};
    TimeSpec _startupTime{0.3};
    Condition* _condition{nullptr};
    Condition* _condition_waiting{nullptr};
    bool _isMain{false};
    union
    {
        void* Ptr;
        intptr_t Code;
    } _exitCode{nullptr};
 
    bool _debug{false};
 
    friend void installSignalHandlers();
    friend class Condition;
};
 
inline Thread::operator handle_type() const
{
  return _handle;
}
 
inline Thread::Attributes::operator handle_type() const
{
  return _attributes;
}
 
inline void Thread::setDebug(bool yn)
{
  _debug = yn;
}
 
inline bool Thread::isDebug() const
{
  return _debug;
}
 
class _MISC_CLASS ThreadMain : public Thread
{
  public:
    ThreadMain();
    int run() override;
};
 
inline ThreadMain::ThreadMain()
  : Thread(true)
{}
 
inline int ThreadMain::run()
{
  return 0;
}
 
}// namespace sf