thread_wrapper.hpp

Go to the documentation of this file.

#pragma once

 
#include "expected.hpp"
#include "scheduler_policy.hpp"
#include <memory>
#include <optional>
#include <string>
#include <thread>
 
#ifdef _WIN32
#    include <libloaderapi.h>
#    include <windows.h>
#else
#    include <dirent.h>
#    include <fstream>
#    include <sys/prctl.h>
#    include <sys/resource.h>
#    include <sys/syscall.h>
#    include <unistd.h>
#endif
 
namespace threadschedule
{
 
namespace detail
{
struct OwningTag
{
};

struct NonOwningTag
{
};
 
template <typename ThreadType, typename OwnershipTag>
class ThreadStorage;

template <typename ThreadType>
class ThreadStorage<ThreadType, OwningTag>
{
  protected:
    ThreadStorage() = default;
 
    [[nodiscard]] auto underlying() noexcept -> ThreadType&
    {
        return thread_;
    }
    [[nodiscard]] auto underlying() const noexcept -> ThreadType const&
    {
        return thread_;
    }
 
    ThreadType thread_;
};

template <typename ThreadType>
class ThreadStorage<ThreadType, NonOwningTag>
{
  protected:
    ThreadStorage() = default;
    explicit ThreadStorage(ThreadType& t) : external_thread_(&t)
    {
    }
 
    [[nodiscard]] auto underlying() noexcept -> ThreadType&
    {
        return *external_thread_;
    }
    [[nodiscard]] auto underlying() const noexcept -> ThreadType const&
    {
        return *external_thread_;
    }
 
    ThreadType* external_thread_ = nullptr; // non-owning
};
 
template <typename ThreadLike>
inline auto configure_thread(ThreadLike& thread, std::string const& name, SchedulingPolicy policy,
                             ThreadPriority priority) -> expected<void, std::error_code>
{
    bool success = true;
    if (!thread.set_name(name).has_value())
        success = false;
    if (!thread.set_scheduling_policy(policy, priority).has_value())
        success = false;
    if (success)
        return {};
    return unexpected(std::make_error_code(std::errc::operation_not_permitted));
}
} // namespace detail

template <typename ThreadType, typename OwnershipTag = detail::OwningTag>
class BaseThreadWrapper : protected detail::ThreadStorage<ThreadType, OwnershipTag>
{
  public:
    using native_handle_type = typename ThreadType::native_handle_type;
    using id = typename ThreadType::id;
 
    BaseThreadWrapper() = default;
    explicit BaseThreadWrapper(ThreadType& t) : detail::ThreadStorage<ThreadType, OwnershipTag>(t)
    {
    }
    virtual ~BaseThreadWrapper() = default;
 
    // Thread management
    void join()
    {
        if (underlying().joinable())
        {
            underlying().join();
        }
    }
 
    void detach()
    {
        if (underlying().joinable())
        {
            underlying().detach();
        }
    }
 
    [[nodiscard]] auto joinable() const noexcept -> bool
    {
        return underlying().joinable();
    }
    [[nodiscard]] auto get_id() const noexcept -> id
    {
        return underlying().get_id();
    }
    [[nodiscard]] auto native_handle() noexcept -> native_handle_type
    {
        return underlying().native_handle();
    }
 
    [[nodiscard]] auto set_name(std::string const& name) -> expected<void, std::error_code>
    {
        return detail::apply_name(native_handle(), name);
    }
 
    [[nodiscard]] auto get_name() const -> std::optional<std::string>
    {
        return detail::read_name(const_cast<BaseThreadWrapper*>(this)->native_handle());
    }
 
    [[nodiscard]] auto set_priority(ThreadPriority priority) -> expected<void, std::error_code>
    {
        return detail::apply_priority(native_handle(), priority);
    }
 
    [[nodiscard]] auto set_scheduling_policy(SchedulingPolicy policy, ThreadPriority priority)
        -> expected<void, std::error_code>
    {
        return detail::apply_scheduling_policy(native_handle(), policy, priority);
    }
 
    [[nodiscard]] auto set_affinity(ThreadAffinity const& affinity) -> expected<void, std::error_code>
    {
        return detail::apply_affinity(native_handle(), affinity);
    }
 
    [[nodiscard]] auto get_affinity() const -> std::optional<ThreadAffinity>
    {
        return detail::read_affinity(const_cast<BaseThreadWrapper*>(this)->native_handle());
    }
 
    // Nice value (process-level, affects all threads)
    static auto set_nice_value(int nice_value) -> bool
    {
#ifdef _WIN32
        // Windows has process priority classes, not nice values
        // We'll use SetPriorityClass for the process
        DWORD priority_class;
        if (nice_value <= -15)
        {
            priority_class = HIGH_PRIORITY_CLASS;
        }
        else if (nice_value <= -10)
        {
            priority_class = ABOVE_NORMAL_PRIORITY_CLASS;
        }
        else if (nice_value < 10)
        {
            priority_class = NORMAL_PRIORITY_CLASS;
        }
        else if (nice_value < 19)
        {
            priority_class = BELOW_NORMAL_PRIORITY_CLASS;
        }
        else
        {
            priority_class = IDLE_PRIORITY_CLASS;
        }
        return SetPriorityClass(GetCurrentProcess(), priority_class) != 0;
#else
        return setpriority(PRIO_PROCESS, 0, nice_value) == 0;
#endif
    }
 
    static auto get_nice_value() -> std::optional<int>
    {
#ifdef _WIN32
        // Get Windows process priority class and map to nice value
        DWORD priority_class = GetPriorityClass(GetCurrentProcess());
        if (priority_class == 0)
        {
            return std::nullopt;
        }
 
        // Map Windows priority class to nice value
        switch (priority_class)
        {
        case HIGH_PRIORITY_CLASS:
            return -15;
        case ABOVE_NORMAL_PRIORITY_CLASS:
            return -10;
        case NORMAL_PRIORITY_CLASS:
            return 0;
        case BELOW_NORMAL_PRIORITY_CLASS:
            return 10;
        case IDLE_PRIORITY_CLASS:
            return 19;
        default:
            return 0;
        }
#else
        errno = 0;
        int const nice = getpriority(PRIO_PROCESS, 0);
        if (errno == 0)
        {
            return nice;
        }
        return std::nullopt;
#endif
    }
 
  protected:
    using detail::ThreadStorage<ThreadType, OwnershipTag>::underlying;
    using detail::ThreadStorage<ThreadType, OwnershipTag>::ThreadStorage;
};

class ThreadWrapper : public BaseThreadWrapper<std::thread, detail::OwningTag>
{
  public:
    ThreadWrapper() = default;
 
    // Construct by taking ownership of an existing std::thread (move)
    ThreadWrapper(std::thread&& t) noexcept
    {
        this->underlying() = std::move(t);
    }
 
    template <typename F, typename... Args>
    explicit ThreadWrapper(F&& f, Args&&... args) : BaseThreadWrapper()
    {
        this->underlying() = std::thread(std::forward<F>(f), std::forward<Args>(args)...);
    }
 
    ThreadWrapper(ThreadWrapper const&) = delete;
    auto operator=(ThreadWrapper const&) -> ThreadWrapper& = delete;
 
    ThreadWrapper(ThreadWrapper&& other) noexcept
    {
        this->underlying() = std::move(other.underlying());
    }
 
    auto operator=(ThreadWrapper&& other) noexcept -> ThreadWrapper&
    {
        if (this != &other)
        {
            if (this->underlying().joinable())
            {
                this->underlying().join();
            }
            this->underlying() = std::move(other.underlying());
        }
        return *this;
    }
 
    ~ThreadWrapper() override
    {
        if (this->underlying().joinable())
        {
            this->underlying().join();
        }
    }
 
    // Ownership transfer to std::thread for APIs that take plain std::thread
    auto release() noexcept -> std::thread
    {
        return std::move(this->underlying());
    }
 
    explicit operator std::thread() && noexcept
    {
        return std::move(this->underlying());
    }
 
    // Factory methods
    template <typename F, typename... Args>
    static auto create_with_config(std::string const& name, SchedulingPolicy policy, ThreadPriority priority, F&& f,
                                   Args&&... args) -> ThreadWrapper
    {
        ThreadWrapper wrapper(std::forward<F>(f), std::forward<Args>(args)...);
        (void)wrapper.set_name(name);
        (void)wrapper.set_scheduling_policy(policy, priority);
        return wrapper;
    }
};

class ThreadWrapperView : public BaseThreadWrapper<std::thread, detail::NonOwningTag>
{
  public:
    ThreadWrapperView(std::thread& t) : BaseThreadWrapper<std::thread, detail::NonOwningTag>(t)
    {
    }
 
    // Non-owning access to the underlying std::thread
    auto get() noexcept -> std::thread&
    {
        return this->underlying();
    }
    [[nodiscard]] auto get() const noexcept -> std::thread const&
    {
        return this->underlying();
    }
};

#if __cplusplus >= 202002L || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
class JThreadWrapper : public BaseThreadWrapper<std::jthread, detail::OwningTag>
{
  public:
    JThreadWrapper() = default;
 
    // Construct by taking ownership of an existing std::jthread (move)
    JThreadWrapper(std::jthread&& t) noexcept : BaseThreadWrapper()
    {
        this->underlying() = std::move(t);
    }
 
    // Ownership transfer to std::jthread for APIs that take plain std::jthread
    auto release() noexcept -> std::jthread
    {
        return std::move(this->underlying());
    }
 
    explicit operator std::jthread() && noexcept
    {
        return std::move(this->underlying());
    }
 
    template <typename F, typename... Args>
    explicit JThreadWrapper(F&& f, Args&&... args) : BaseThreadWrapper()
    {
        this->underlying() = std::jthread(std::forward<F>(f), std::forward<Args>(args)...);
    }
 
    JThreadWrapper(JThreadWrapper const&) = delete;
    auto operator=(JThreadWrapper const&) -> JThreadWrapper& = delete;
 
    JThreadWrapper(JThreadWrapper&& other) noexcept
    {
        this->underlying() = std::move(other.underlying());
    }
 
    auto operator=(JThreadWrapper&& other) noexcept -> JThreadWrapper&
    {
        if (this != &other)
        {
            this->underlying() = std::move(other.underlying());
        }
        return *this;
    }
 
    // jthread-specific functionality
    void request_stop()
    {
        this->underlying().request_stop();
    }
    [[nodiscard]] auto stop_requested() const noexcept -> bool
    {
        return this->underlying().get_stop_token().stop_requested();
    }
    [[nodiscard]] auto get_stop_token() const noexcept -> std::stop_token
    {
        return this->underlying().get_stop_token();
    }
    [[nodiscard]] auto get_stop_source() noexcept -> std::stop_source
    {
        return this->underlying().get_stop_source();
    }
 
    // Factory methods
    template <typename F, typename... Args>
    static auto create_with_config(std::string const& name, SchedulingPolicy policy, ThreadPriority priority, F&& f,
                                   Args&&... args) -> JThreadWrapper
    {
        JThreadWrapper wrapper(std::forward<F>(f), std::forward<Args>(args)...);
        (void)wrapper.set_name(name);
        (void)wrapper.set_scheduling_policy(policy, priority);
        return wrapper;
    }
};

class JThreadWrapperView : public BaseThreadWrapper<std::jthread, detail::NonOwningTag>
{
  public:
    JThreadWrapperView(std::jthread& t) : BaseThreadWrapper<std::jthread, detail::NonOwningTag>(t)
    {
    }
 
    void request_stop()
    {
        this->underlying().request_stop();
    }
    [[nodiscard]] auto stop_requested() const noexcept -> bool
    {
        return this->underlying().get_stop_token().stop_requested();
    }
    [[nodiscard]] auto get_stop_token() const noexcept -> std::stop_token
    {
        return this->underlying().get_stop_token();
    }
    [[nodiscard]] auto get_stop_source() noexcept -> std::stop_source
    {
        return this->underlying().get_stop_source();
    }
 
    // Non-owning access to the underlying std::jthread
    auto get() noexcept -> std::jthread&
    {
        return this->underlying();
    }
    [[nodiscard]] auto get() const noexcept -> std::jthread const&
    {
        return this->underlying();
    }
};
#else
// Fallback for compilers without C++20 support
using JThreadWrapper = ThreadWrapper;
using JThreadWrapperView = ThreadWrapperView;
#endif // C++20

class ThreadByNameView
{
  public:
#ifdef _WIN32
    using native_handle_type = void*; // unsupported placeholder
#else
    using native_handle_type = Tid; // Linux TID
#endif
 
    explicit ThreadByNameView(const std::string& name)
    {
#ifdef _WIN32
        // Not supported on Windows in this implementation
        (void)name;
#else
        DIR* dir = opendir("/proc/self/task");
        if (dir == nullptr)
            return;
        struct dirent* entry = nullptr;
        while ((entry = readdir(dir)) != nullptr)
        {
            if (entry->d_name[0] == '.')
                continue;
            std::string tid_str(entry->d_name);
            std::string path = std::string("/proc/self/task/") + tid_str + "/comm";
            std::ifstream in(path);
            if (!in)
                continue;
            std::string current;
            std::getline(in, current);
            if (!current.empty() && current.back() == '\n')
                current.pop_back();
            if (current == name)
            {
                handle_ = static_cast<pid_t>(std::stoi(tid_str));
                break;
            }
        }
        closedir(dir);
#endif
    }
 
    [[nodiscard]] auto found() const noexcept -> bool
    {
#ifdef _WIN32
        return false;
#else
        return handle_ > 0;
#endif
    }
 
    [[nodiscard]] auto set_name(std::string const& name) const -> expected<void, std::error_code>
    {
#ifdef _WIN32
        return unexpected(std::make_error_code(std::errc::function_not_supported));
#else
        if (!found())
            return unexpected(std::make_error_code(std::errc::no_such_process));
        return detail::apply_name(handle_, name);
#endif
    }
 
    [[nodiscard]] auto get_name() const -> std::optional<std::string>
    {
#ifdef _WIN32
        return std::nullopt;
#else
        if (!found())
            return std::nullopt;
        return detail::read_name(handle_);
#endif
    }
 
    [[nodiscard]] auto native_handle() const noexcept -> native_handle_type
    {
        return handle_;
    }
 
    [[nodiscard]] auto set_priority(ThreadPriority priority) const -> expected<void, std::error_code>
    {
#ifdef _WIN32
        return unexpected(std::make_error_code(std::errc::function_not_supported));
#else
        if (!found())
            return unexpected(std::make_error_code(std::errc::no_such_process));
        return detail::apply_priority(handle_, priority);
#endif
    }
 
    [[nodiscard]] auto set_scheduling_policy(SchedulingPolicy policy, ThreadPriority priority) const
        -> expected<void, std::error_code>
    {
#ifdef _WIN32
        return unexpected(std::make_error_code(std::errc::function_not_supported));
#else
        if (!found())
            return unexpected(std::make_error_code(std::errc::no_such_process));
        return detail::apply_scheduling_policy(handle_, policy, priority);
#endif
    }
 
    [[nodiscard]] auto set_affinity(ThreadAffinity const& affinity) const -> expected<void, std::error_code>
    {
#ifdef _WIN32
        return unexpected(std::make_error_code(std::errc::function_not_supported));
#else
        if (!found())
            return unexpected(std::make_error_code(std::errc::no_such_process));
        return detail::apply_affinity(handle_, affinity);
#endif
    }
 
  private:
#ifdef _WIN32
    native_handle_type handle_ = nullptr;
#else
    native_handle_type handle_ = 0;
#endif
};

class ThreadInfo
{
  public:
#ifdef _WIN32
    using native_handle_type = HANDLE;
#else
    using native_handle_type = pthread_t;
#endif
 
    ThreadInfo() : tid_(get_thread_id())
    {
        bind_current_thread_handle();
    }
 
    explicit ThreadInfo(Tid tid) : tid_(tid)
    {
    }
 
    [[nodiscard]] auto thread_id() const noexcept -> Tid
    {
        return tid_;
    }
 
    [[nodiscard]] auto set_name(std::string const& name) const -> expected<void, std::error_code>
    {
        if (has_native_handle())
            return detail::apply_name(native_handle(), name);
        return detail::apply_name(tid_, name);
    }
 
    [[nodiscard]] auto get_name() const -> std::optional<std::string>
    {
        if (has_native_handle())
            return detail::read_name(native_handle());
        return detail::read_name(tid_);
    }
 
    [[nodiscard]] auto set_priority(ThreadPriority priority) const -> expected<void, std::error_code>
    {
        if (has_native_handle())
            return detail::apply_priority(native_handle(), priority);
        return detail::apply_priority(tid_, priority);
    }
 
    [[nodiscard]] auto set_scheduling_policy(SchedulingPolicy policy, ThreadPriority priority) const
        -> expected<void, std::error_code>
    {
        if (has_native_handle())
            return detail::apply_scheduling_policy(native_handle(), policy, priority);
        return detail::apply_scheduling_policy(tid_, policy, priority);
    }
 
    [[nodiscard]] auto set_affinity(ThreadAffinity const& affinity) const -> expected<void, std::error_code>
    {
        if (has_native_handle())
            return detail::apply_affinity(native_handle(), affinity);
        return detail::apply_affinity(tid_, affinity);
    }
 
    [[nodiscard]] auto get_affinity() const -> std::optional<ThreadAffinity>
    {
        if (has_native_handle())
            return detail::read_affinity(native_handle());
        return detail::read_affinity(tid_);
    }
 
    [[nodiscard]] auto get_policy() const -> std::optional<SchedulingPolicy>
    {
        if (has_native_handle())
            return detail::read_scheduling_policy(native_handle());
        return detail::read_scheduling_policy(tid_);
    }
 
    [[nodiscard]] auto get_priority() const -> std::optional<int>
    {
        if (has_native_handle())
            return detail::read_priority(native_handle());
        return detail::read_priority(tid_);
    }
 
    static auto hardware_concurrency() -> unsigned int
    {
        return std::thread::hardware_concurrency();
    }
 
    static auto get_thread_id() -> Tid
    {
#ifdef _WIN32
        return GetCurrentThreadId();
#else
        return static_cast<pid_t>(syscall(SYS_gettid));
#endif
    }
 
    static auto get_current_policy() -> std::optional<SchedulingPolicy>
    {
        return ThreadInfo().get_policy();
    }
 
    static auto get_current_priority() -> std::optional<int>
    {
        return ThreadInfo().get_priority();
    }
 
  private:
    void bind_current_thread_handle()
    {
#ifdef _WIN32
        HANDLE real_handle = nullptr;
        if (DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &real_handle,
                            THREAD_SET_INFORMATION | THREAD_QUERY_INFORMATION, FALSE, 0) != 0)
        {
            nativeHandle_ = real_handle;
            nativeHandleOwner_ = std::shared_ptr<void>(real_handle, [](void* handle) {
                if (handle)
                    CloseHandle(static_cast<HANDLE>(handle));
            });
            hasNativeHandle_ = true;
        }
#else
        nativeHandle_ = pthread_self();
        hasNativeHandle_ = true;
#endif
    }
 
    [[nodiscard]] auto has_native_handle() const noexcept -> bool
    {
        return hasNativeHandle_;
    }
 
    [[nodiscard]] auto native_handle() const noexcept -> native_handle_type
    {
        return nativeHandle_;
    }
 
    Tid tid_{};
#ifdef _WIN32
    native_handle_type nativeHandle_ = nullptr;
    std::shared_ptr<void> nativeHandleOwner_;
#else
    native_handle_type nativeHandle_{};
#endif
    bool hasNativeHandle_{false};
};
 
} // namespace threadschedule