thread_backend.hpp

Go to the documentation of this file.

#pragma once
 
#include "../expected.hpp"
#include "scheduling/native.hpp"
#ifdef _WIN32
#  include "unique_handle.hpp"
#endif
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <tuple>
 
#ifdef _WIN32
#  include "windows_api.hpp"
#  include <libloaderapi.h>
#else
#  include <sys/prctl.h>
#  include <sys/resource.h>
#  include <sys/syscall.h>
#  include <unistd.h>
#endif
 
namespace threadschedule::detail
{
class thread_identity_state
{
public:
  void
  publish(native_thread_id tid)
  {
    {
      std::lock_guard<std::mutex> lock(mutex_);
      tid_ = tid;
      ready_ = true;
    }
    ready_condition_.notify_all();
  }
 
  [[nodiscard]] auto
  wait() -> native_thread_id
  {
    std::unique_lock<std::mutex> lock(mutex_);
    ready_condition_.wait(lock, [this] { return ready_; });
    return tid_;
  }
 
private:
  std::mutex mutex_;
  std::condition_variable ready_condition_;
  native_thread_id tid_{};
  bool ready_{ false };
};
 
[[nodiscard]] inline auto
current_native_thread_id() noexcept -> native_thread_id
{
#ifdef _WIN32
  return GetCurrentThreadId();
#else
  return static_cast<pid_t>(syscall(SYS_gettid));
#endif
}
 
struct owning_tag
{
};
struct non_owning_tag
{
};
 
template <typename ThreadType, typename OwnershipTag>
class thread_storage;
 
template <typename ThreadType>
class thread_storage<ThreadType, owning_tag>
{
protected:
  thread_storage() = default;
 
  [[nodiscard]] auto
  underlying() noexcept -> ThreadType&
  {
    return thread_;
  }
  [[nodiscard]] auto
  underlying() const noexcept -> ThreadType const&
  {
    return thread_;
  }
 
  ThreadType thread_;
};
 
template <typename ThreadType>
class thread_storage<ThreadType, non_owning_tag>
{
protected:
  thread_storage() = default;
  explicit thread_storage(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, native_scheduling_policy policy,
                 native_thread_priority priority) -> expected<void, std::error_code>
{
  auto named = thread.set_name(name);
  if (!named)
    return unexpected(named.error());
  return thread.set_scheduling_policy(policy, priority);
}
 
template <typename ThreadLike>
inline auto
configure_thread(ThreadLike& thread, native_thread_config const& config) -> expected<void, std::error_code>
{
  if (config.name)
    {
      auto named = thread.set_name(*config.name);
      if (!named)
        return unexpected(named.error());
    }
  if (config.scheduling)
    {
      auto scheduled = thread.configure(*config.scheduling);
      if (!scheduled)
        return unexpected(scheduled.error());
    }
  if (config.affinity.has_value())
    return thread.set_affinity(*config.affinity);
  return {};
}
template <typename ThreadType, typename OwnershipTag = detail::owning_tag>
class basic_thread_backend : protected detail::thread_storage<ThreadType, OwnershipTag>
{
public:
  using native_handle_type = typename ThreadType::native_handle_type;
  using id = typename ThreadType::id;
 
  basic_thread_backend() = default;
  explicit basic_thread_backend(ThreadType& t) : detail::thread_storage<ThreadType, OwnershipTag>(t) {}
  basic_thread_backend(ThreadType& t, native_thread_id tid)
      : detail::thread_storage<ThreadType, OwnershipTag>(t), native_id_(tid)
  {
  }
  virtual ~basic_thread_backend() = default;
 
  // Thread management
  void
  join()
  {
    if (underlying().joinable())
      {
        underlying().join();
        native_id_ = {};
      }
  }
 
  void
  detach()
  {
    if (underlying().joinable())
      {
        underlying().detach();
        native_id_ = {};
      }
  }
 
  [[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
  {
    if (!joinable())
      return native_handle_type{};
    return underlying().native_handle();
  }
 
  [[nodiscard]] auto
  set_name(std::string const& name) -> expected<void, std::error_code>
  {
    if (!joinable())
      return no_such_thread();
    return detail::apply_name(native_handle(), name);
  }
 
  [[nodiscard]] auto
  get_name() const -> expected<std::string, std::error_code>
  {
    if (!joinable())
      return no_such_thread();
    return detail::read_name(const_cast<basic_thread_backend*>(this)->native_handle());
  }
 
  [[nodiscard]] auto
  set_priority(native_thread_priority priority) -> expected<void, std::error_code>
  {
    if (!joinable())
      return no_such_thread();
#ifdef _WIN32
    return detail::apply_priority(native_handle(), priority);
#else
    return detail::apply_scheduling_config(native_handle(), native_id_,
                                           detail::native_schedule::posix_nice(priority.value()));
#endif
  }
 
  [[nodiscard]] auto
  set_scheduling_policy(native_scheduling_policy policy, native_thread_priority priority)
      -> expected<void, std::error_code>
  {
    if (!joinable())
      return no_such_thread();
    return detail::apply_scheduling_policy(native_handle(), policy, priority);
  }
 
  [[nodiscard]] auto
  configure(native_scheduling_config const& config) -> expected<void, std::error_code>
  {
    if (!joinable())
      return no_such_thread();
    return detail::apply_scheduling_config(native_handle(), native_id_, config);
  }
 
  [[nodiscard]] auto
  set_nice_value(int nice_value) -> expected<void, std::error_code>
  {
    if (!joinable())
      return no_such_thread();
#ifdef _WIN32
    return detail::apply_nice_value(native_handle(), nice_value);
#else
    if (native_id_ <= 0)
      return unexpected(std::make_error_code(std::errc::operation_not_supported));
    return detail::apply_nice_value(native_id_, nice_value);
#endif
  }
 
  [[nodiscard]] auto
  get_nice_value() const -> expected<int, std::error_code>
  {
    if (!joinable())
      return no_such_thread();
    return detail::read_effective_nice(const_cast<basic_thread_backend*>(this)->native_handle(), native_id_);
  }
 
  [[nodiscard]] auto
  configure(native_thread_config const& config) -> expected<void, std::error_code>
  {
    return detail::configure_thread(*this, config);
  }
 
  [[nodiscard]] auto
  set_affinity(native_thread_affinity const& affinity) -> expected<void, std::error_code>
  {
    if (!joinable())
      return no_such_thread();
    return detail::apply_affinity_checked(native_handle(), affinity);
  }
 
  [[nodiscard]] auto
  get_affinity() const -> expected<native_thread_affinity, std::error_code>
  {
    if (!joinable())
      return no_such_thread();
    return detail::read_affinity(const_cast<basic_thread_backend*>(this)->native_handle());
  }
 
  [[nodiscard]] auto
  native_id() const noexcept -> native_thread_id
  {
    return native_id_;
  }
 
protected:
  [[nodiscard]] static auto
  no_such_thread() -> unexpected<std::error_code>
  {
    return unexpected(std::make_error_code(std::errc::no_such_process));
  }
 
  void
  set_native_id(native_thread_id tid) noexcept
  {
    native_id_ = tid;
  }
 
  using detail::thread_storage<ThreadType, OwnershipTag>::underlying;
  using detail::thread_storage<ThreadType, OwnershipTag>::thread_storage;
 
  native_thread_id native_id_{};
};
 
class thread_backend : public basic_thread_backend<std::thread, detail::owning_tag>
{
public:
  thread_backend() = default;
 
  [[nodiscard]] auto
  get() noexcept -> std::thread&
  {
    return this->underlying();
  }
 
  [[nodiscard]] auto
  get() const noexcept -> std::thread const&
  {
    return this->underlying();
  }
 
  // Construct by taking ownership of an existing std::thread (move)
  thread_backend(std::thread&& t) noexcept
  {
    this->underlying() = std::move(t);
  }
 
  thread_backend(std::thread&& t, native_thread_id tid) noexcept
  {
    this->underlying() = std::move(t);
    this->set_native_id(tid);
  }
 
  template <typename F, typename... Args>
  explicit thread_backend(F&& f, Args&&... args) : basic_thread_backend()
  {
    auto identity = std::make_shared<thread_identity_state>();
    using function_type = std::decay_t<F>;
    auto arguments = std::make_tuple(std::forward<Args>(args)...);
    this->underlying() = std::thread(
        [identity, function = function_type(std::forward<F>(f)), arguments = std::move(arguments)]() mutable
          {
            identity->publish(current_native_thread_id());
            std::apply([&function](auto&&... stored)
                         { std::invoke(std::move(function), std::forward<decltype(stored)>(stored)...); },
                       std::move(arguments));
          });
    this->set_native_id(identity->wait());
  }
 
  thread_backend(thread_backend const&) = delete;
  auto operator=(thread_backend const&) -> thread_backend& = delete;
 
  thread_backend(thread_backend&& other) noexcept
  {
    this->underlying() = std::move(other.underlying());
    this->set_native_id(other.native_id());
    other.set_native_id({});
  }
 
  auto
  operator=(thread_backend&& other) noexcept -> thread_backend&
  {
    if (this != &other)
      {
        if (this->underlying().joinable())
          {
            this->underlying().join();
          }
        this->underlying() = std::move(other.underlying());
        this->set_native_id(other.native_id());
        other.set_native_id({});
      }
    return *this;
  }
 
  ~thread_backend() 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
  {
    auto result = std::move(this->underlying());
    this->set_native_id({});
    return result;
  }
 
  explicit
  operator std::thread() && noexcept
  {
    return release();
  }
 
  // Factory methods
  template <typename F, typename... Args>
  static auto
  create_with_config(std::string const& name, native_scheduling_policy policy, native_thread_priority priority, F&& f,
                     Args&&... args) -> thread_backend
  {
    thread_backend wrapper(std::forward<F>(f), std::forward<Args>(args)...);
    (void)wrapper.set_name(name);
    (void)wrapper.set_scheduling_policy(policy, priority);
    return wrapper;
  }
 
  template <typename F, typename... Args>
  static auto
  create_with_config(native_thread_config const& config, F&& f, Args&&... args) -> thread_backend
  {
    thread_backend wrapper(std::forward<F>(f), std::forward<Args>(args)...);
    (void)wrapper.configure(config);
    return wrapper;
  }
};
 
class thread_view_backend : public basic_thread_backend<std::thread, detail::non_owning_tag>
{
public:
  thread_view_backend(std::thread& t) : basic_thread_backend<std::thread, detail::non_owning_tag>(t) {}
 
  thread_view_backend(std::thread& t, native_thread_id tid)
      : basic_thread_backend<std::thread, detail::non_owning_tag>(t, tid)
  {
  }
 
  // 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();
  }
};
 
class thread_info
{
public:
#ifdef _WIN32
  using native_handle_type = HANDLE;
#else
  using native_handle_type = pthread_t;
#endif
 
  thread_info() : tid_(get_thread_id())
  {
    bind_current_thread_handle();
  }
 
  explicit thread_info(native_thread_id tid) : tid_(tid) {}
 
  [[nodiscard]] auto
  thread_id() const noexcept -> native_thread_id
  {
    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 -> expected<std::string, std::error_code>
  {
    if (has_native_handle())
      return detail::read_name(native_handle());
    return detail::read_name(tid_);
  }
 
  [[nodiscard]] auto
  set_priority(native_thread_priority priority) const -> expected<void, std::error_code>
  {
#ifdef _WIN32
    if (has_native_handle())
      return detail::apply_priority(native_handle(), priority);
    return detail::apply_priority(tid_, priority);
#else
    if (has_native_handle())
      return detail::apply_scheduling_config(native_handle(), tid_,
                                             detail::native_schedule::posix_nice(priority.value()));
    return detail::apply_scheduling_config(tid_, tid_, detail::native_schedule::posix_nice(priority.value()));
#endif
  }
 
  [[nodiscard]] auto
  set_scheduling_policy(native_scheduling_policy policy, native_thread_priority 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
  configure(native_scheduling_config const& config) const -> expected<void, std::error_code>
  {
    if (has_native_handle())
      return detail::apply_scheduling_config(native_handle(), tid_, config);
    return detail::apply_scheduling_config(tid_, tid_, config);
  }
 
  [[nodiscard]] auto
  configure(native_thread_config const& config) const -> expected<void, std::error_code>
  {
    return detail::configure_thread(*this, config);
  }
 
  [[nodiscard]] auto
  set_affinity(native_thread_affinity const& affinity) const -> expected<void, std::error_code>
  {
    if (has_native_handle())
      return detail::apply_affinity_checked(native_handle(), affinity);
    return detail::apply_affinity_checked(tid_, affinity);
  }
 
  [[nodiscard]] auto
  get_affinity() const -> expected<native_thread_affinity, std::error_code>
  {
    if (has_native_handle())
      return detail::read_affinity(native_handle());
    return detail::read_affinity(tid_);
  }
 
  [[nodiscard]] auto
  get_policy() const -> std::optional<native_scheduling_policy>
  {
    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() -> native_thread_id
  {
#ifdef _WIN32
    return GetCurrentThreadId();
#else
    return static_cast<pid_t>(syscall(SYS_gettid));
#endif
  }
 
  static auto
  get_current_policy() -> std::optional<native_scheduling_policy>
  {
    return thread_info().get_policy();
  }
 
  static auto
  get_current_priority() -> std::optional<int>
  {
    return thread_info().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)
      {
        native_handle_owner_ = std::make_shared<unique_handle>(real_handle);
        native_handle_ = native_handle_owner_->get();
        has_native_handle_ = true;
      }
#else
    native_handle_ = pthread_self();
    has_native_handle_ = true;
#endif
  }
 
  [[nodiscard]] auto
  has_native_handle() const noexcept -> bool
  {
    return has_native_handle_;
  }
 
  [[nodiscard]] auto
  native_handle() const noexcept -> native_handle_type
  {
    return native_handle_;
  }
 
  native_thread_id tid_{};
#ifdef _WIN32
  native_handle_type native_handle_ = nullptr;
  std::shared_ptr<unique_handle> native_handle_owner_;
#else
  native_handle_type native_handle_{};
#endif
  bool has_native_handle_{ false };
};
 
} // namespace threadschedule::detail