thread.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_THREAD_HPP
#define JOIN_CORE_THREAD_HPP
 
// libjoin.
#include <join/utils.hpp>
 
// C++.
#include <system_error>
#include <type_traits>
#include <functional>
#include <memory>
#include <atomic>
 
// C.
#include <sys/syscall.h>
#include <pthread.h>
#include <unistd.h>
 
namespace join
{
    class Invoker
    {
    public:
        Invoker () = delete;
 
    private:
        template <class Function, class... Args>
        explicit Invoker (int core, int prio, size_t stackSize, bool prefault, Function&& func, Args&&... args)
        : _func (std::bind (std::forward<Function> (func), std::forward<Args> (args)...))
        , _core (core)
        , _priority (prio)
        , _prefault (prefault)
        , _done (false)
        {
            pthread_attr_t attr;
            pthread_attr_init (&attr);
 
            if (stackSize > 0)
            {
                const int err = pthread_attr_setstacksize (&attr, stackSize);
                if (err != 0)
                {
                    pthread_attr_destroy (&attr);
                    throw std::system_error (err, std::system_category (), "pthread_attr_setstacksize failed");
                }
            }
 
            const int err = pthread_create (&_handle, &attr, _routine, this);
            pthread_attr_destroy (&attr);
            if (err != 0)
            {
                throw std::system_error (err, std::system_category (), "pthread_create failed");  // LCOV_EXCL_LINE
            }
        }
 
    public:
        Invoker (const Invoker& other) = delete;
 
        Invoker& operator= (const Invoker& other) = delete;
 
        Invoker (Invoker&& other) = delete;
 
        Invoker& operator= (Invoker&& other) = delete;
 
        ~Invoker () = default;
 
    private:
        static int prefault () noexcept;
 
        static void* _routine (void* context);
 
        void* routine ();
 
        std::function<void ()> _func;
 
        pthread_t _handle = {};
 
        std::atomic_int _core{-1};
 
        std::atomic_int _priority{0};
 
        bool _prefault = false;
 
        static constexpr pid_t _invalidId = -1;
 
        std::atomic<pid_t> _id{_invalidId};
 
        std::atomic_bool _done;
 
        friend class Thread;
    };
 
    class Thread
    {
    public:
        static constexpr pid_t invalidId = Invoker::_invalidId;
 
        Thread () noexcept = default;
 
        template <class Function, class... Args>
        explicit Thread (Function&& func, Args&&... args)
            requires (!std::is_arithmetic_v<std::decay_t<Function>>)
        : Thread (-1, 0, 0, false, std::forward<Function> (func), std::forward<Args> (args)...)
        {
        }
 
        template <class Function, class... Args>
        explicit Thread (int core, int prio, Function&& func, Args&&... args)
            requires (!std::is_arithmetic_v<std::decay_t<Function>>)
        : Thread (core, prio, 0, false, std::forward<Function> (func), std::forward<Args> (args)...)
        {
        }
 
        template <class Function, class... Args>
        explicit Thread (int core, int prio, size_t stackSize, bool prefault, Function&& func, Args&&... args)
        : _invoker (new Invoker (core, prio, stackSize, prefault, std::forward<Function> (func),
                                 std::forward<Args> (args)...))
        {
        }
 
        Thread (const Thread& other) = delete;
 
        Thread& operator= (const Thread& other) = delete;
 
        Thread (Thread&& other) noexcept;
 
        Thread& operator= (Thread&& other) noexcept;
 
        ~Thread ();
 
        int affinity (int core);
 
        static int affinity (pthread_t handle, int core);
 
        int affinity () const noexcept;
 
        int priority (int prio);
 
        static int priority (pthread_t handle, int prio);
 
        int priority () const noexcept;
 
        bool joinable () const noexcept;
 
        bool running () const noexcept;
 
        void join () noexcept;
 
        bool tryJoin () noexcept;
 
        void cancel () noexcept;
 
        void swap (Thread& other) noexcept;
 
        static pid_t currentId () noexcept
        {
            static thread_local pid_t tid __attribute__ ((tls_model ("initial-exec"))) = 0;
            if (JOIN_UNLIKELY (tid == 0))
            {
                static const int registered = ::pthread_atfork (nullptr, nullptr, [] () {
                    tid = 0;
                });
                static_cast<void> (registered);
                tid = static_cast<pid_t> (::syscall (SYS_gettid));
            }
            return tid;
        }
 
        pid_t id () const noexcept;
 
        pthread_t handle () const noexcept;
 
    private:
        std::unique_ptr<Invoker> _invoker;
    };
}
 
#endif