thread_internal.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2016-2025 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 */
 
// ============================================================================
// This file is for internal use in µOS++ and should not be included
// in applications.
/*
 * (References are to ISO/IEC DIS 14882:2017)
 *
 * A trivially copyable class is a class:
 * - where each copy constructor, move constructor, copy assignment
 * operator, and move assignment operator (15.8, 16.5.3) is either
 * deleted or trivial,
 * - that has at least one non-deleted copy constructor, move
 * constructor, copy assignment operator, or move assignment operator, and
 * - that has a trivial, non-deleted destructor (15.4).
 */
 
// ----------------------------------------------------------------------------
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
 
// ----------------------------------------------------------------------------
 
class thread
{
public:
  using native_handle_type = os::rtos::thread*; // See 33.2.3
 
  class id
  {
  public:
    id () noexcept;
 
    explicit id (native_handle_type system_thread) noexcept;
 
    id (const id&) = default;
    id&
    operator= (const id&)
        = default;
 
    ~id () = default;
 
  private:
    friend class thread;
    friend struct std::hash<thread::id>;
 
    // Only two of them, the other 4 are defined in terms of these.
    friend bool
    operator== (thread::id x, thread::id y) noexcept;
 
    friend bool
    operator< (thread::id x, thread::id y) noexcept;
 
    // The id is actually a pointer to the system thread.
    native_handle_type native_thread_;
  };
 
  thread () noexcept = default;
 
  template <typename F, //
            typename... Args>
  explicit thread (F&& f, Args&&... args);
 
  ~thread ();
 
  thread (const thread&) = delete;
  thread (thread&& t) noexcept;
 
  thread&
  operator= (const thread&)
      = delete;
  thread&
  operator= (thread&& t) noexcept;
 
  // ----------------------------------------------------------------------
 
  void
  swap (thread& t) noexcept;
 
  bool
  joinable (void) const noexcept;
 
  void
  join (void);
 
  void
  detach (void);
 
  id
  get_id (void) const noexcept;
 
  native_handle_type
  native_handle ();
 
  static unsigned
  hardware_concurrency (void) noexcept;
 
private:
  template <typename F_T>
  static void
  run_function_object (const void* func_object);
 
  template <typename F_T>
  static void
  delete_function_object (const void* func_obj);
 
  void
  delete_system_thread (void);
 
  // The current implementation creates temporary id() objects
  // and copies (moves?) them here, but this is not a problem,
  // the id is actually a pointer.
  id id_;
 
  using function_object_deleter_t = void (*) (void*);
  function_object_deleter_t function_object_deleter_ = nullptr;
 
public:
};
 
// Enforce the copyable requirement.
static_assert (std::is_trivially_copyable<thread::id>::value,
               "thread::id must be trivially copyable");
 
// ========================================================================
 
void
swap (thread& x, thread& y) noexcept;
 
/*
 * Relational operators allow thread::id objects to be used as keys
 * in associative containers.
 */
bool
operator== (thread::id x, thread::id y) noexcept;
bool
operator!= (thread::id x, thread::id y) noexcept;
bool
operator< (thread::id x, thread::id y) noexcept;
bool
operator<= (thread::id x, thread::id y) noexcept;
bool
operator> (thread::id x, thread::id y) noexcept;
bool
operator>= (thread::id x, thread::id y) noexcept;
 
#if 0
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& out, thread::id id);
#endif
 
// Hash support
template <class T>
struct hash;
 
template <>
struct hash<thread::id>;
 
// ========================================================================
namespace this_thread
{
 
  thread::id
  get_id () noexcept;
 
  void
  yield () noexcept;
 
  template <typename Clock_T = os::estd::chrono::systick_clock, typename Rep_T,
            typename Period_T>
  constexpr void
  sleep_for (const std::chrono::duration<Rep_T, Period_T>& rel_time);
 
  template <typename Clock_T, typename Duration_T>
  void
  sleep_until (const std::chrono::time_point<Clock_T, Duration_T>& abs_time);
 
} /* namespace this_thread */
 
// ========================================================================
// Inline & template implementations.
 
// ========================================================================
 
inline void
swap (thread& x, thread& y) noexcept
{
  x.swap (y);
}
 
inline bool
operator== (thread::id x, thread::id y) noexcept
{
  return x.native_thread_ == y.native_thread_;
}
 
inline bool
operator!= (thread::id x, thread::id y) noexcept
{
  return !(x == y);
}
 
inline bool
operator< (thread::id x, thread::id y) noexcept
{
  return x.native_thread_ < y.native_thread_;
}
 
inline bool
operator<= (thread::id x, thread::id y) noexcept
{
  return !(y < x);
}
 
inline bool
operator> (thread::id x, thread::id y) noexcept
{
  return y < x;
}
 
inline bool
operator>= (thread::id x, thread::id y) noexcept
{
  return !(x < y);
}
 
// ========================================================================
 
inline thread::id::id () noexcept : native_thread_ (nullptr)
{
}
 
inline thread::id::id (native_handle_type native_thread) noexcept
    : native_thread_ (native_thread)
{
}
 
// ------------------------------------------------------------------------
 
inline thread::id
thread::get_id () const noexcept
{
  return id_;
}
 
inline thread::native_handle_type
thread::native_handle ()
{
  return id_.native_thread_;
}
 
inline unsigned
thread::hardware_concurrency () noexcept
{
  return 1;
}
 
template <typename F_T>
void
thread::run_function_object (const void* func_obj)
{
  os::trace::printf ("%s()\n", __PRETTY_FUNCTION__);
 
  using Function_object = F_T;
  const Function_object* f = static_cast<const Function_object*> (func_obj);
  (*f) ();
}
 
template <typename F_T>
void
thread::delete_function_object (const void* func_obj)
{
  os::trace::printf ("%s()\n", __PRETTY_FUNCTION__);
 
  using Function_object = F_T;
  const Function_object* f = static_cast<const Function_object*> (func_obj);
 
  // The delete now has the knowledge required to
  // correctly delete the object (i.e. the object size).
  delete f;
}
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
template <typename Callable_T, typename... Args_T>
thread::thread (Callable_T&& f, Args_T&&... args)
{
  // static_assert(std::is_same<Attr_T, os::rtos::thread::attr_t>::value,
  // "first param must be thread_attr_t*");
 
  os::trace::printf ("%s() @%p\n", __PRETTY_FUNCTION__, this);
 
  using Function_object = decltype (std::bind (
      std::forward<Callable_T> (f), std::forward<Args_T> (args)...));
 
  // Dynamic allocation! The size depends on the number of arguments.
  // This creates a small problem, since both running the function
  // and deleting the object requires the type. It is passes as
  // template functions.
  Function_object* funct_obj = new Function_object (std::bind (
      std::forward<Callable_T> (f), std::forward<Args_T> (args)...));
 
  // The function to start the thread is a custom proxy that
  // knows how to get the variadic arguments.
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wcast-function-type"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wcast-function-type"
#endif
  id_ = id{ new os::rtos::thread (
      reinterpret_cast<os::rtos::thread::func_t> (
          &run_function_object<Function_object>),
      reinterpret_cast<os::rtos::thread::func_args_t> (funct_obj)) };
#pragma GCC diagnostic pop
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wcast-function-type-strict"
#endif
  // The deleter, to be used during destruction.
  function_object_deleter_ = reinterpret_cast<function_object_deleter_t> (
      &delete_function_object<Function_object>);
#pragma GCC diagnostic pop
}
 
#pragma GCC diagnostic pop
 
// ========================================================================
 
namespace this_thread
{
 
  inline void __attribute__ ((always_inline))
  yield () noexcept
  {
    os::rtos::this_thread::yield ();
  }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
  inline thread::id
  get_id () noexcept
  {
    return thread::id (&os::rtos::this_thread::thread ());
  }
 
#pragma GCC diagnostic pop
 
  // This implementation currently supports only short
  // delays, since it uses the ticks timer.
 
  // Note: there is no absolute guarantee that the
  // sleep will not return earlier, so the application
  // might need to retry.
 
  // Note the constexpr return type, which tries to compute everything at
  // compile time. And, for constant durations, it succeeds.
#if 0
  template<class Rep_T, class Period_T>
  constexpr void
  sleep_for (const std::chrono::duration<Rep_T, Period_T>& rel_time)
    {
      using namespace std::chrono;
 
      if (rel_time > duration<Rep_T, Period_T>::zero ())
        {
          // Round up to micros, in case of nanos.
          microseconds micros =
          os::estd::chrono::ceil<microseconds> (rel_time);
 
          // Round up to ticks.
#if 0
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
          os::rtos::thread::sleep (
              (os::rtos::systicks_t) (os::estd::chrono::ceil<
                  systicks> (micros).count ()));
#pragma GCC diagnostic pop
 
#else
          // The code seems better with this variant, otherwise it
          // does not optimise constant calls.
          os::rtos::Systick_clock::sleep_for (
              os::rtos::Systick_clock::ticks_cast (
                  micros.count ()));
#endif
 
        }
    }
#endif
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
  template <typename Clock_T, class Rep_T, class Period_T>
  constexpr void
  sleep_for (const std::chrono::duration<Rep_T, Period_T>& rel_time)
  {
    using namespace std::chrono;
 
    using clock = Clock_T;
    using sleep_rep = typename clock::sleep_rep;
 
    if (rel_time > duration<Rep_T, Period_T>::zero ())
      {
        sleep_rep d = static_cast<sleep_rep> (
            os::estd::chrono::ceil<typename clock::duration> (rel_time)
                .count ());
 
        clock::sleep_for (d);
      }
  }
 
#pragma GCC diagnostic pop
 
  template <typename Clock_T, typename Duration_T>
  void
  sleep_until (const std::chrono::time_point<Clock_T, Duration_T>& abs_time)
  {
    using clock = Clock_T;
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
    auto now = clock::now ();
 
    while (now < abs_time)
      {
        sleep_for (abs_time - now);
        now = clock::now ();
      }
 
#pragma GCC diagnostic pop
  }
 
  template <typename Duration_T>
  void
  sleep_until (const std::chrono::time_point<os::estd::chrono::realtime_clock,
                                             Duration_T>& abs_time)
  {
    using clock = os::estd::chrono::realtime_clock;
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
    auto now = clock::now ();
    while (now < abs_time)
      {
        typename clock::sleep_rep d
            = (os::estd::chrono::ceil<typename clock::sleep_duration> (abs_time
                                                                       - now))
                  .count ();
        clock::sleep_for (d);
        now = clock::now ();
      }
 
#pragma GCC diagnostic pop
  }
 
  template <typename Duration_T>
  void
  sleep_until (const std::chrono::time_point<os::estd::chrono::systick_clock,
                                             Duration_T>& abs_time)
  {
    using clock = os::estd::chrono::systick_clock;
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
    auto now = clock::now ();
    while (now < abs_time)
      {
        typename clock::sleep_rep d
            = (os::estd::chrono::ceil<typename clock::sleep_duration> (abs_time
                                                                       - now))
                  .count ();
        clock::sleep_for (d);
        now = clock::now ();
      }
 
#pragma GCC diagnostic pop
  }
} /* namespace this_thread */
 
#pragma GCC diagnostic pop