A namespace for functions applying to the current thread. More...

Functions
thread::id	get_id () noexcept
	Return the id of the current running thread.

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)
	Sleep for a given duration.

template<typename Clock_T , typename Duration_T >
void	sleep_until (const std::chrono::time_point< Clock_T, Duration_T > &abs_time)
	Sleep until a given time point.

template<typename Duration_T >
void	sleep_until (const std::chrono::time_point< os::estd::chrono::realtime_clock, Duration_T > &abs_time)

template<typename Duration_T >
void	sleep_until (const std::chrono::time_point< os::estd::chrono::systick_clock, Duration_T > &abs_time)

void	yield () noexcept
	Yield the CPU to the next ready thread.

Detailed Description

Function Documentation

◆ get_id()

thread::id this_thread::get_id ( )

inlinenoexcept

Definition at line 405 of file thread_internal.h.

  {
    return thread::id (&os::rtos::this_thread::thread ());
  }

◆ sleep_for()

template<typename Clock_T = os::estd::chrono::systick_clock, typename Rep_T , typename Period_T >

constexpr void this_thread::sleep_for ( const std::chrono::duration< Rep_T, Period_T > & rel_time )

constexpr

Parameters

[in] rel_time sleep duration.

extra Clock_T is an extension to the standard

Definition at line 467 of file thread_internal.h.

  {
    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);
      }
  }

◆ sleep_until() [1/3]

template<typename Clock_T , typename Duration_T >

void this_thread::sleep_until ( const std::chrono::time_point< Clock_T, Duration_T > & abs_time )

Parameters

[in] abs_time Absolute time point.

Definition at line 488 of file thread_internal.h.

  {
    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
  }

◆ sleep_until() [2/3]

template<typename Duration_T >

void this_thread::sleep_until ( const std::chrono::time_point< os::estd::chrono::realtime_clock, Duration_T > & abs_time )

Definition at line 511 of file thread_internal.h.

  {
    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
  }

◆ sleep_until() [3/3]

template<typename Duration_T >

void this_thread::sleep_until ( const std::chrono::time_point< os::estd::chrono::systick_clock, Duration_T > & abs_time )

Definition at line 538 of file thread_internal.h.

  {
    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
  }

◆ yield()

void this_thread::yield ( void )