thread.h

Go to the documentation of this file.

#ifndef THREAD_H
#define THREAD_H
 
#include "config.h"
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
#include "pthread.h"
#elif ORIGINAL_COMPILER_MSVC
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#endif
 
#include "error.h"
#include "functional"
#include "hash.h"
#include "ownerPtr.h"
#include "zeit.h"
 
 
namespace original {
    template <typename DERIVED>
    class threadBase : public comparable<DERIVED>,
                       public hashable<DERIVED>,
                       public printable {
    protected:
        template<typename Callback>
        class threadData
        {
            Callback c;
        public:
            explicit threadData(Callback c);
 
            static void* run(void* arg);
        };
 
        [[nodiscard]] virtual bool valid() const = 0;
 
        [[nodiscard]] virtual ul_integer id() const = 0;
    public:
 
        explicit threadBase() noexcept = default;
 
        ~threadBase() noexcept override = default;
 
        threadBase(const threadBase&) = delete; 
        threadBase& operator=(const threadBase&) = delete; 
 
        threadBase(threadBase&& other) noexcept = default; 
        threadBase& operator=(threadBase&& other) noexcept = default; 
 
        explicit operator bool() const;
 
        bool operator!() const;
 
        [[nodiscard]] virtual bool joinable() const = 0;
 
        virtual void join() = 0;
 
        virtual void detach() = 0;
 
        std::string className() const override;
 
        std::string toString(bool enter) const override;
    };
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
    class pThread final : public threadBase<pThread> {
        pthread_t handle; 
        bool is_joinable; 
 
        [[nodiscard]] bool valid() const override;
    public:
        explicit pThread();
 
        template<typename Callback, typename... ARGS>
        explicit pThread(Callback c, ARGS&&... args);
 
        pThread(pThread&& other) noexcept;
 
        pThread& operator=(pThread&& other) noexcept;
 
        [[nodiscard]] ul_integer id() const override;
 
        [[nodiscard]] bool joinable() const override;
 
        integer compareTo(const pThread &other) const override;
 
        u_integer toHash() const noexcept override;
 
        std::string className() const override;
 
        void join() override;
 
        void detach() override;
 
        ~pThread() override;
    };
#elif ORIGINAL_COMPILER_MSVC
    class wThread final : public threadBase<wThread> {
        HANDLE handle;
        bool is_joinable;
 
        [[nodiscard]] bool valid() const override;
    public:
        explicit wThread();
 
        template<typename Callback, typename... ARGS>
        explicit wThread(Callback c, ARGS&&... args...);
 
        wThread(wThread&& other) noexcept;
 
        wThread& operator=(wThread&& other) noexcept;
 
        [[nodiscard]] ul_integer id() const override;
 
        [[nodiscard]] bool joinable() const override;
 
        integer compareTo(const wThread &other) const override;
 
        u_integer toHash() const noexcept override;
 
        std::string className() const override;
 
        void join() override;
 
        void detach() override;
 
        ~wThread() override;
    };
#endif
 
    class thread final : public threadBase<thread> {
        #if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
        pThread thread_; 
        #elif ORIGINAL_COMPILER_MSVC
        wThread thread_;
        #endif
        bool will_join;  
 
        enum class joinPolicy {
            AUTO_JOIN,   
            AUTO_DETACH, 
        };
 
        [[nodiscard]] bool valid() const override;
    public:
 
        static ul_integer thisId();
 
        static inline void sleep(const time::duration& d);
 
        static constexpr auto AUTO_JOIN = joinPolicy::AUTO_JOIN;
 
        static constexpr auto AUTO_DETACH = joinPolicy::AUTO_DETACH;
 
        explicit thread();
 
        template<typename Callback, typename... ARGS>
        explicit thread(Callback c, ARGS&&... args);
 
        template<typename Callback, typename... ARGS>
        explicit thread(Callback c, joinPolicy policy, ARGS&&... args);
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
        explicit thread(pThread p_thread, joinPolicy policy = AUTO_JOIN);
#elif ORIGINAL_COMPILER_MSVC
        explicit thread(wThread w_thread, joinPolicy policy = AUTO_JOIN);
#endif
 
        thread(const thread&) = delete; 
        thread& operator=(const thread&) = delete; 
 
        thread(thread&& other) noexcept;
 
        thread(thread&& other, joinPolicy policy) noexcept;
 
        thread& operator=(thread&& other) noexcept;
 
        [[nodiscard]] ul_integer id() const override;
 
        [[nodiscard]] bool joinable() const override;
 
        [[nodiscard]] integer compareTo(const thread &other) const override;
 
        [[nodiscard]] u_integer toHash() const noexcept override;
 
        [[nodiscard]] std::string className() const override;
 
        void join() override;
 
        void detach() override;
 
        ~thread() override;
    };
}
 
 
template <typename DERIVED>
template <typename Callback>
original::threadBase<DERIVED>::threadData<Callback>::threadData(Callback c)
    : c(std::move(c)) {}
 
template <typename DERIVED>
template <typename Callback>
void* original::threadBase<DERIVED>::threadData<Callback>::run(void* arg)
{
    auto self = ownerPtr<threadData>(static_cast<threadData*>(arg));
    try {
        self->c();
    }catch (const error& e) {
        throw sysError("Thread callback execution failed with message: " + e.message());
    }
    return nullptr;
}
 
template <typename DERIVED>
original::threadBase<DERIVED>::operator bool() const
{
    return this->valid();
}
 
template <typename DERIVED>
bool original::threadBase<DERIVED>::operator!() const
{
    return !this->valid();
}
 
template<typename DERIVED>
std::string original::threadBase<DERIVED>::className() const {
    return "threadBase";
}
 
template<typename DERIVED>
std::string original::threadBase<DERIVED>::toString(bool enter) const {
    std::stringstream ss;
    ss << "(" << this->className() << " ";
    ss << "#" << this->id();
    ss << ")";
    if (enter)
        ss << "\n";
    return ss.str();
}
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
inline original::pThread::pThread() : handle(), is_joinable() {}
 
template<typename Callback, typename... ARGS>
original::pThread::pThread(Callback c, ARGS&&... args) : handle(), is_joinable(true)
{
    auto bound_lambda =
    [func = std::forward<Callback>(c), ...lambda_args = std::forward<ARGS>(args)]() mutable {
        std::invoke(std::move(func), std::move(lambda_args)...);
    };
 
    using bound_callback = decltype(bound_lambda);
    using bound_thread_data = threadData<bound_callback>;
 
    auto task = new bound_thread_data(std::move(bound_lambda));
 
    if (const int code = pthread_create(&this->handle, nullptr, &bound_thread_data::run, task); code != 0)
    {
        delete task;
        throw sysError("Failed to create thread (pthread_create returned " + formatString(code) + ")");
    }
}
 
inline bool original::pThread::valid() const
{
    return this->handle != pthread_t{};
}
 
inline original::pThread::pThread(pThread&& other) noexcept
    : pThread() {
    this->operator=(std::move(other));
}
 
inline original::pThread& original::pThread::operator=(pThread&& other) noexcept
{
    if (this == &other) {
        return *this;
    }
 
    if (this->is_joinable && this->valid()) {
        pthread_detach(this->handle);
    }
 
    this->handle = other.handle;
    other.handle = {};
    this->is_joinable = other.is_joinable;
    other.is_joinable = false;
    return *this;
}
 
inline original::ul_integer original::pThread::id() const {
    ul_integer id = 0;
    std::memcpy(&id, &this->handle, sizeof(pthread_t));
    return id;
}
 
inline bool original::pThread::joinable() const
{
    return this->is_joinable;
}
 
inline original::integer
original::pThread::compareTo(const pThread& other) const {
    if (this->id() != other.id())
        return this->id() > other.id() ? 1 : -1;
    return 0;
}
 
inline original::u_integer
original::pThread::toHash() const noexcept {
    return hash<pThread>::hashFunc(this->id());
}
 
inline std::string original::pThread::className() const {
    return "pThread";
}
 
inline void original::pThread::join() {
    if (this->is_joinable){
        if (const int code = pthread_join(this->handle, nullptr);
            code != 0){
            throw sysError("Failed to join thread (pthread_join returned " + formatString(code) + ")");
        }
        this->is_joinable = false;
        this->handle = {};
    }
}
 
inline void original::pThread::detach() {
    if (this->is_joinable){
        if (const int code = pthread_detach(this->handle);
            code != 0){
            throw sysError("Failed to detach thread (pthread_detach returned " + formatString(code) + ")");
        }
        this->is_joinable = false;
        this->handle = {};
    }
}
 
inline original::pThread::~pThread()
{
    if (this->is_joinable) {
        try {
            this->detach();
        } catch (...) {
            std::cerr << "Fatal error in pThread destructor" << std::endl;
            std::terminate();
        }
    }
}
#elif ORIGINAL_COMPILER_MSVC
inline bool original::wThread::valid() const
{
    return this->handle != HANDLE{};
}
 
inline original::wThread::wThread() : handle(), is_joinable() {}
 
template <typename Callback, typename ... ARGS>
original::wThread::wThread(Callback c, ARGS&&... args, ...) : handle(), is_joinable(true)
{
    auto bound_lambda =
    [func = std::forward<Callback>(c), ...lambda_args = std::forward<ARGS>(args)]() mutable {
        std::invoke(std::move(func), std::move(lambda_args)...);
    };
 
    using bound_callback = decltype(bound_lambda);
    using bound_thread_data = threadData<bound_callback>;
 
    auto task = new bound_thread_data(std::move(bound_lambda));
 
    static auto threadEntry = [](LPVOID param) -> DWORD {
        bound_thread_data::run(param);
        return 0;
    };
 
    this->handle = CreateThread(nullptr, 0, threadEntry, task, 0, nullptr);
    if (this->handle == nullptr) {
        delete task;
        throw sysError("Failed to create thread (CreateThread returned null)");
    }
}
 
inline original::wThread::wThread(wThread&& other) noexcept : wThread()
{
    this->operator=(std::move(other));
}
 
inline original::wThread& original::wThread::operator=(wThread&& other) noexcept
{
    if (this == &other) {
        return *this;
    }
 
    if (this->is_joinable && this->valid()) {
        CloseHandle(this->handle);
    }
 
    this->handle = other.handle;
    other.handle = {};
    this->is_joinable = other.is_joinable;
    other.is_joinable = false;
    return *this;
}
 
inline original::ul_integer original::wThread::id() const
{
    ul_integer id = 0;
    std::memcpy(&id, &this->handle, sizeof(HANDLE));
    return id;
}
 
inline bool original::wThread::joinable() const
{
    return this->is_joinable;
}
 
inline original::integer original::wThread::compareTo(const wThread& other) const
{
    if (this->id() != other.id())
        return this->id() > other.id() ? 1 : -1;
    return 0;
}
 
inline original::u_integer original::wThread::toHash() const noexcept
{
    return hash<HANDLE>::hashFunc(this->id());
}
 
inline std::string original::wThread::className() const
{
    return "wThread";
}
 
inline void original::wThread::join()
{
    WaitForSingleObject(this->handle, INFINITE);
    this->is_joinable = false;
    this->handle = {};
}
 
inline void original::wThread::detach()
{
    CloseHandle(this->handle);
    this->is_joinable = false;
    this->handle = {};
}
 
inline original::wThread::~wThread()
{
    if (this->is_joinable) {
        try {
            this->detach();
        } catch (...) {
            std::cerr << "Fatal error in wThread destructor" << std::endl;
            std::terminate();
        }
    }
}
#endif
 
inline bool original::thread::valid() const
{
    return this->thread_.operator bool();
}
 
inline original::ul_integer
original::thread::thisId() {
    ul_integer id = 0;
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
    auto handle = pthread_self();
    std::memcpy(&id, &handle, sizeof(pthread_t));
#elif ORIGINAL_COMPILER_MSVC
    const auto handle = GetCurrentThreadId();
    std::memcpy(&id, &handle, sizeof(HANDLE));
#endif
    return id;
}
 
inline void original::thread::sleep(const time::duration& d)
{
    if (d.value() < 0)
        return;
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
    const auto deadline = time::point::now() + d;
    const auto ts = deadline.toTimespec();
    int ret;
 
    while (true) {
        if (ret = clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &ts, nullptr)
            ; ret == 0) break;
        if (errno == EINTR) continue;
        if (errno == EINVAL) {
            if (time::point::now() >= deadline) return;
        }
        throw sysError("Failed to sleep thread (clock_nano-sleep returned " + formatString(ret) +
                      ", errno: " + std::to_string(errno) + ")");
    }
#elif ORIGINAL_COMPILER_MSVC
    Sleep(d.toDWMilliseconds());
#endif
}
 
inline original::thread::thread()
    : will_join(true) {}
 
template <typename Callback, typename ... ARGS>
original::thread::thread(Callback c, ARGS&&... args)
    : thread_(std::forward<Callback>(c), std::forward<ARGS>(args)...), will_join(true) {}
 
template <typename Callback, typename ... ARGS>
original::thread::thread(Callback c, const joinPolicy policy, ARGS&&... args)
    : thread_(std::forward<Callback>(c), std::forward<ARGS>(args)...), will_join(policy == AUTO_JOIN) {}
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
inline original::thread::thread(pThread p_thread, const joinPolicy policy)
    : thread_(std::move(p_thread)), will_join(policy == AUTO_JOIN) {}
#elif ORIGINAL_COMPILER_MSVC
inline original::thread::thread(wThread w_thread, const joinPolicy policy)
    : thread_(std::move(w_thread)), will_join(policy == AUTO_JOIN) {}
#endif
 
inline original::thread::thread(thread&& other) noexcept
    : thread_(std::move(other.thread_)), will_join(true) {}
 
inline original::thread::thread(thread&& other, const joinPolicy policy) noexcept
    : thread_(std::move(other.thread_)), will_join(policy == AUTO_JOIN) {}
 
inline original::thread& original::thread::operator=(thread&& other) noexcept {
    if (this == &other) {
        return *this;
    }
 
    this->thread_ = std::move(other.thread_);
    this->will_join = other.will_join;
    other.will_join = false;
    return *this;
}
 
inline original::integer
original::thread::compareTo(const thread& other) const {
    return this->thread_.compareTo(other.thread_);
}
 
inline original::u_integer
original::thread::toHash() const noexcept {
    return this->thread_.toHash();
}
 
inline std::string original::thread::className() const {
    return "thread";
}
 
inline void original::thread::join()
{
    this->thread_.join();
}
 
inline void original::thread::detach()
{
    this->thread_.detach();
}
 
inline original::thread::~thread()
{
    try {
        this->will_join ? this->thread_.join() : this->thread_.detach();
    } catch (const sysError& e) {
        std::cerr << "Fatal error in thread destructor: " << e.what() << std::endl;
        std::terminate();
    }
}
 
inline original::ul_integer original::thread::id() const {
    return this->thread_.id();
}
 
inline bool original::thread::joinable() const
{
    return this->thread_.joinable();
}
 
#endif //THREAD_H