thread Class Reference

Standard thread. More...

#include <thread_internal.h>

Classes
class	id
	Thread unique id. More...

Public Types
using	native_handle_type = os::rtos::thread *

Public Member Functions
	thread () noexcept=default
template<typename Callable_T , typename... Args_T>
	thread (Callable_T &&f, Args_T &&... args)
	thread (const thread &)=delete
template<typename F , typename... Args>
	thread (F &&f, Args &&... args)
	thread (thread &&t) noexcept
	~thread ()
void	detach (void)
id	get_id (void) const noexcept
void	join (void)
bool	joinable (void) const noexcept
native_handle_type	native_handle ()
thread &	operator= (const thread &)=delete
thread &	operator= (thread &&t) noexcept
void	swap (thread &t) noexcept

Static Public Member Functions
static unsigned	hardware_concurrency (void) noexcept

Private Types
using	function_object_deleter_t = void(*)(void *)

Private Member Functions
void	delete_system_thread (void)

Static Private Member Functions
template<typename F_T >
static void	delete_function_object (const void *func_obj)
template<typename F_T >
static void	run_function_object (const void *func_object)

Private Attributes
function_object_deleter_t	function_object_deleter_ = nullptr
id	id_

Detailed Description

Definition at line 39 of file thread_internal.h.

Member Typedef Documentation

function_object_deleter_t

using thread::function_object_deleter_t = void (*) (void*)

private

Definition at line 146 of file thread_internal.h.

native_handle_type

using thread::native_handle_type = os::rtos::thread*

Definition at line 42 of file thread_internal.h.

Constructor & Destructor Documentation

thread() [1/5]

thread::thread ( )

defaultnoexcept

thread() [2/5]

template<typename F , typename... Args>

thread::thread ( F &&  f, Args &&...  args  )

explicit

~thread()

thread::~thread

(

)

Definition at line 51 of file thread-cpp.h.

{
  os::trace::printf ("%s() @%p\n", __func__, this);
  if (joinable ())
    {
      os::trace::printf ("%s() @%p attempt to destruct a running thread\n",
                         __func__, this);
      std::abort (); // in ISO it is std::terminate()
    }
 
  delete_system_thread ();
}

References delete_system_thread(), joinable(), and os::trace::printf().

thread() [3/5]

thread::thread ( const thread &  )

delete

thread() [4/5]

thread::thread ( thread &&  t )

noexcept

Definition at line 16 of file thread-cpp.h.

{
  swap (t);
}

References swap().

thread() [5/5]

template<typename Callable_T , typename... Args_T>

thread::thread	(	Callable_T &&	f,
		Args_T &&...	args
	)

Definition at line 344 of file thread_internal.h.

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

Member Function Documentation

delete_function_object()

template<typename F_T >

void thread::delete_function_object ( const void *  func_obj )

staticprivate

Definition at line 325 of file thread_internal.h.

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

delete_system_thread()

void thread::delete_system_thread ( void  )

private

Definition at line 35 of file thread-cpp.h.

{
  if (id_ != id ())
    {
      void* args = id_.native_thread_->function_args ();
      if (args != nullptr && function_object_deleter_ != nullptr)
        {
          // Manually delete the function object used to store arguments.
          function_object_deleter_ (args);
        }
 
      // Manually delete the system thread.
      delete id_.native_thread_;
    }
}

References os::rtos::thread::function_args(), function_object_deleter_, id_, and thread::id::native_thread_.

Referenced by ~thread(), and join().

detach()

void thread::detach

(

void

)

Definition at line 91 of file thread-cpp.h.

{
  os::trace::printf ("%s() @%p\n", __func__, this);
  if (id_ != id ())
    {
      id_.native_thread_->detach ();
    }
 
  // The detached thread will continue to run, but we'll not have
  // access to it from here, not even to delete it.
  // TODO: arrange to delete it at exit()?
 
  id_ = id ();
  os::trace::printf ("%s() @%p detached\n", __func__, this);
}

References os::rtos::thread::detach(), id_, thread::id::native_thread_, and os::trace::printf().

get_id()

thread::id thread::get_id ( void  ) const

inlinenoexcept

Definition at line 295 of file thread_internal.h.

{
  return id_;
}

hardware_concurrency()

unsigned thread::hardware_concurrency ( void  )

inlinestaticnoexcept

Definition at line 307 of file thread_internal.h.

{
  return 1;
}

join()

void thread::join

(

void

)

Definition at line 80 of file thread-cpp.h.

{
  os::trace::printf ("%s() @%p\n", __func__, this);
 
  delete_system_thread ();
 
  id_ = id ();
  os::trace::printf ("%s() @%p joined\n", __func__, this);
}

References delete_system_thread(), id_, and os::trace::printf().

joinable()

bool thread::joinable ( void  ) const

noexcept

Definition at line 74 of file thread-cpp.h.

{
  return !(id_ == thread::id ());
}

References id_.

Referenced by ~thread().

native_handle()

thread::native_handle_type thread::native_handle ( )

inline

Definition at line 301 of file thread_internal.h.

{
  return id_.native_thread_;
}

operator=() [1/2]

thread & thread::operator= ( const thread &  )

delete

operator=() [2/2]

thread & thread::operator= ( thread &&  t )

noexcept

Definition at line 22 of file thread-cpp.h.

{
  if (joinable ())
    {
      os::trace::printf ("%s() @%p attempt to assign a running thread\n",
                         __func__, this);
      std::abort (); // in ISO it is std::terminate()
    }
  swap (t);
  return *this;
}

References os::trace::printf(), and swap().

run_function_object()

template<typename F_T >

void thread::run_function_object ( const void *  func_object )

staticprivate

Definition at line 314 of file thread_internal.h.

{
  os::trace::printf ("%s()\n", __PRETTY_FUNCTION__);
 
  using Function_object = F_T;
  const Function_object* f = static_cast<const Function_object*> (func_obj);
  (*f) ();
}

swap()

void thread::swap ( thread &  t )

noexcept

Definition at line 67 of file thread-cpp.h.

{
  std::swap (id_, t.id_);
  std::swap (function_object_deleter_, t.function_object_deleter_);
}

Member Data Documentation

function_object_deleter_

function_object_deleter_t thread::function_object_deleter_ = nullptr

private

Definition at line 147 of file thread_internal.h.

Referenced by delete_system_thread().

id_

id thread::id_

private

Definition at line 144 of file thread_internal.h.

Referenced by delete_system_thread(), detach(), join(), and joinable().

---

The documentation for this class was generated from the following files:

• thread_internal.h
• thread-cpp.h