RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

librtemscxx: Fix white space to match the coding standard

Browse Source
This commit is contained in:
Chris Johns
2020-10-09 10:44:36 +11:00
parent 6f2a219f57
commit 89a22be079
4 changed files with 208 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
cpukit/include/rtems/error.hpp
View File

@@ -50,19 +50,19 @@ namespace rtems
{
const rtems_status_code sc;
public:
runtime_error (const rtems_status_code sc);
runtime_error (const rtems_status_code sc, const std::string& what);
runtime_error (const rtems_status_code sc, const char* what);
~runtime_error ();
runtime_error(const rtems_status_code sc);
runtime_error(const rtems_status_code sc, const std::string& what);
runtime_error(const rtems_status_code sc, const char* what);
~runtime_error();
};
/**
* Throw a rtems::runtime_error exception if the RTEMS status code is
* not RTEMS_SUCCESSFUL.
*/
void runtime_error_check (const rtems_status_code sc);
void runtime_error_check (const rtems_status_code sc, const std::string& what);
void runtime_error_check (const rtems_status_code sc, const char* what);
void runtime_error_check(const rtems_status_code sc);
void runtime_error_check(const rtems_status_code sc, const std::string& what);
void runtime_error_check(const rtems_status_code sc, const char* what);
};
#endif

144
cpukit/include/rtems/thread.hpp
View File

@@ -83,14 +83,14 @@ namespace rtems
* executing thread. The stack size is set to the configured minimum
* stack size.
*/
attributes ();
attributes();
/*
* Copy construct the thread attributes.
*
* @param attr The attributes to copy.
*/
attributes (const attributes& attr);
attributes(const attributes& attr);
/**
* Set the name of the thread. The thread is a classic API thread and
@@ -98,7 +98,7 @@ namespace rtems
*
* @param name The name as a string.
*/
void set_name (const std::string& name);
void set_name(const std::string& name);
/**
* Set the name of the thread. The thread is a classic API thread and
@@ -106,28 +106,28 @@ namespace rtems
*
* @param name The name as a string.
*/
void set_name (const char* name);
void set_name(const char* name);
/**
* Get the name of the thread.
*
* @retval const std::string& The name of the thread.
*/
const std::string& get_name () const;
const std::string& get_name() const;
/**
* Set the priority of the thread.
*
* @param priority The POSIX API priority of the thread.
*/
void set_priority (int priority);
void set_priority(int priority);
/**
* Get the POSIX API priority of the thread.
*
* @retval int The POSIX API thread priority.
*/
int get_priority () const;
int get_priority() const;
/**
* Set the stack size. If the size is less than the configured minimum
@@ -135,38 +135,38 @@ namespace rtems
*
* @param size The stack size in bytes.
*/
void set_stack_size (size_t size);
void set_stack_size(size_t size);
/**
* Get the stack size.
*
* @retval size_t The stack size in bytes.
*/
size_t get_stack_size () const;
size_t get_stack_size() const;
/**
* Set the scheduler name. If not set no scheduler is set.
*
* @parrm scheduler The name of the scheduler.
*/
void set_scheduler (const std::string& scheduler);
void set_scheduler(const std::string& scheduler);
/**
* Set the scheduler name. If not set no scheduler is set.
*/
void set_scheduler (const char* scheduler);
void set_scheduler(const char* scheduler);
/**
* Get scheduler name.
*/
const std::string& get_scheduler ();
const std::string& get_scheduler();
/**
* Get the attributes' scheduler attribute for the thread.
*
* @return sched_attr The attributes' scheduler attribute
*/
sched_attr get_scheduler_attr () const;
sched_attr get_scheduler_attr() const;
/**
* Set the scheduler policy for the thread. This call sets the
@@ -174,12 +174,12 @@ namespace rtems
*
* @param policy The scheduler policy.
*/
void set_scheduler_policy (sched_policy policy);
void set_scheduler_policy(sched_policy policy);
/**
* Get the scheduler policy for the thread.
*/
sched_policy get_scheduler_policy () const;
sched_policy get_scheduler_policy() const;
/**
* Commit any changes to the executing thread.
@@ -187,7 +187,7 @@ namespace rtems
* @note only the priority and attribute of a thread can be changed. The
* name and stack size are ignored.
*/
void commit ();
void commit();
/**
* Update the attribute values from the executing thread. The attributes
@@ -197,18 +197,18 @@ namespace rtems
* this method is called. Except for the name and stack size any local
* changes made will lost then the update call is made.
*/
void update ();
void update();
/**
* Copy operator.
*/
attributes& operator= (const attributes& attr);
attributes& operator=(const attributes& attr);
/**
* The comparison operator does not check the name or stack size
* of a thread.
*/
bool operator== (const attributes& attr) const;
bool operator==(const attributes& attr) const;
private:
std::string name; /**< Name of the thread */
@@ -243,7 +243,7 @@ namespace rtems
*/
class thread
{
friend void* thread_generic_entry (void* arg);
friend void* thread_generic_entry(void* arg);
/**
* Base state class to interface to derived template of the thread
@@ -251,9 +251,9 @@ namespace rtems
*/
struct state_base
{
virtual ~state_base ();
virtual const attributes get_attributes () = 0;
virtual void run () = 0;
virtual ~state_base();
virtual const attributes get_attributes() = 0;
virtual void run() = 0;
};
/**
@@ -278,23 +278,23 @@ namespace rtems
*/
class id {
public:
id () noexcept : id_ (0) { }
explicit id (pthread_t id_) : id_ (id_) { }
id() noexcept : id_(0) { }
explicit id(pthread_t id_) : id_(id_) { }
private:
pthread_t id_;
friend class thread;
friend bool operator== (thread::id l, thread::id r) noexcept;
friend bool operator==(thread::id l, thread::id r) noexcept;
template<class CharT, class Traits>
friend std::basic_ostream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& out, thread::id id_);
operator<<(std::basic_ostream<CharT, Traits>& out, thread::id id_);
};
/**
* The default thread constructions.
*/
thread () noexcept = default;
thread() noexcept = default;
/**
* The std::thread equivalent constructor. The attributes will be the
@@ -302,7 +302,7 @@ namespace rtems
* configured minimum stack size.
*/
template<typename F, typename... Args>
explicit thread (F&& func, Args&&... args);
explicit thread(F&& func, Args&&... args);
/**
* Create a thread with the provided attributes. The entry point and
@@ -310,12 +310,12 @@ namespace rtems
*/
template <typename A, typename F, typename ...Args,
class = enable_if_attributes<A>>
explicit thread (A&& attr, F&& func, Args&&... args);
explicit thread(A&& attr, F&& func, Args&&... args);
/**
* Move the thread id to this instance.
*/
thread& operator= (thread&& thread_);
thread& operator=(thread&& thread_);
void swap(thread& thread_) noexcept;
@@ -328,10 +328,10 @@ namespace rtems
/*
* Constrain use. These are not available.
*/
thread (thread&) = delete;
thread (const thread&) = delete;
thread (const thread&&) = delete;
thread& operator= (const thread&) = delete;
thread(thread&) = delete;
thread(const thread&) = delete;
thread(const thread&&) = delete;
thread& operator=(const thread&) = delete;
std::thread::id get_id() const noexcept;
@@ -349,20 +349,20 @@ namespace rtems
Parms p;
template<size_t Index>
static std::__tuple_element_t<Index, Parms>&& declval ();
static std::__tuple_element_t<Index, Parms>&& declval();
template<size_t... Ind>
auto invoke (std::_Index_tuple<Ind...>)
noexcept (noexcept (std::invoke (declval<Ind>()...)))
-> decltype (std::invoke (declval<Ind> ()...)) {
return std::invoke (std::get<Ind> (std::move (p))...);
auto invoke(std::_Index_tuple<Ind...>)
noexcept(noexcept(std::invoke(declval<Ind>()...)))
-> decltype(std::invoke(declval<Ind>()...)) {
return std::invoke(std::get<Ind>(std::move(p))...);
}
using indices =
typename std::_Build_index_tuple<std::tuple_size<Parms>::value>::__type;
void run () {
invoke (indices ());
void run() {
invoke(indices());
}
};
@@ -376,17 +376,17 @@ namespace rtems
const attributes attr;
Invoker i;
state (const attributes& attr, Invoker&& i)
: attr (attr),
i (std::forward<Invoker> (i)) {
state(const attributes& attr, Invoker&& i)
: attr(attr),
i(std::forward<Invoker>(i)) {
}
const attributes get_attributes () override {
const attributes get_attributes() override {
return attr;
}
void run () override {
i.run ();
void run() override {
i.run();
}
};
@@ -396,9 +396,9 @@ namespace rtems
*/
template<typename Invoker>
static state_ptr
make_state (const attributes& attr, Invoker&& i) {
make_state(const attributes& attr, Invoker&& i) {
using state_impl = state<Invoker>;
return state_ptr{ new state_impl (attr, std::forward<Invoker> (i)) };
return state_ptr{ new state_impl(attr, std::forward<Invoker>(i)) };
}
/**
@@ -413,11 +413,11 @@ namespace rtems
*/
template<typename F, typename... Args>
static invoker<decayed_tuple<F, Args...>>
make_invoker (F&& func, Args&&... args)
make_invoker(F&& func, Args&&... args)
{
return {
decayed_tuple<F, Args...> {
std::forward<F> (func), std::forward<Args> (args)...
std::forward<F>(func), std::forward<Args>(args)...
}
};
}
@@ -425,55 +425,55 @@ namespace rtems
/**
* Create and start the thread.
*/
void start_thread (state_ptr s);
void start_thread(state_ptr s);
};
template <class T>
inline typename std::decay<T>::type
decay_copy (T&& t) {
return std::forward<T> (t);
decay_copy(T&& t) {
return std::forward<T>(t);
}
template<typename F, typename... Args>
thread::thread (F&& func, Args&&... args)
: id_ (0) {
thread::thread(F&& func, Args&&... args)
: id_(0) {
attributes attr;
start_thread (
make_state (attr,
make_invoker (decay_copy (std::forward<F> (func)),
decay_copy (std::forward<Args> (args))...))
start_thread(
make_state(attr,
make_invoker(decay_copy(std::forward<F>(func)),
decay_copy(std::forward<Args>(args))...))
);
}
template<typename A, typename F, typename... Args,
class = thread::enable_if_attributes<A>>
thread::thread (A&& attr, F&& func, Args&&... args)
: id_ (0) {
start_thread (
make_state (attr,
make_invoker (decay_copy (std::forward<F> (func)),
decay_copy (std::forward<Args> (args))...))
thread::thread(A&& attr, F&& func, Args&&... args)
: id_(0) {
start_thread(
make_state(attr,
make_invoker(decay_copy(std::forward<F>(func)),
decay_copy(std::forward<Args>(args))...))
);
}
inline std::thread::id thread::get_id() const noexcept {
return std::thread::id (id_.id_);
return std::thread::id(id_.id_);
}
inline bool
operator== (thread::id l, thread::id r) noexcept {
operator==(thread::id l, thread::id r) noexcept {
return l.id_ == r.id_;
}
inline bool
operator!= (thread::id l, thread::id r) noexcept {
operator!=(thread::id l, thread::id r) noexcept {
return !(l == r);
}
template<class C, class T>
inline std::basic_ostream<C, T>&
operator<< (std::basic_ostream<C, T>& out, thread::id id_) {
return out << std::thread::id (id_.id_);
operator<<(std::basic_ostream<C, T>& out, thread::id id_) {
return out << std::thread::id(id_.id_);
}
};
};

34
cpukit/librtemscxx/error.cpp
View File

@@ -29,23 +29,23 @@
namespace rtems
{
runtime_error::runtime_error (const rtems_status_code sc)
: std::runtime_error (::rtems_status_text (sc)),
sc (sc)
runtime_error::runtime_error(const rtems_status_code sc)
: std::runtime_error(::rtems_status_text(sc)),
sc(sc)
{
}
runtime_error::runtime_error (const rtems_status_code sc,
const std::string& what)
: std::runtime_error (what + ": " + ::rtems_status_text (sc)),
sc (sc)
runtime_error::runtime_error(const rtems_status_code sc,
const std::string& what)
: std::runtime_error(what + ": " + ::rtems_status_text(sc)),
sc(sc)
{
}
runtime_error::runtime_error (const rtems_status_code sc,
const char* what)
: std::runtime_error (std::string (what) + ": " + ::rtems_status_text (sc)),
sc (sc)
runtime_error::runtime_error(const rtems_status_code sc,
const char* what)
: std::runtime_error(std::string(what) + ": " + ::rtems_status_text(sc)),
sc(sc)
{
}
@@ -54,26 +54,26 @@ namespace rtems
}
void
runtime_error_check (const rtems_status_code sc)
runtime_error_check(const rtems_status_code sc)
{
if (sc != RTEMS_SUCCESSFUL) {
throw runtime_error (sc);
throw runtime_error(sc);
}
}
void
runtime_error_check (const rtems_status_code sc, const std::string& what)
runtime_error_check(const rtems_status_code sc, const std::string& what)
{
if (sc != RTEMS_SUCCESSFUL) {
throw runtime_error (sc, what);
throw runtime_error(sc, what);
}
}
void
runtime_error_check (const rtems_status_code sc, const char* what)
runtime_error_check(const rtems_status_code sc, const char* what)
{
if (sc != RTEMS_SUCCESSFUL) {
throw runtime_error (sc, what);
throw runtime_error(sc, what);
}
}
};

224
cpukit/librtemscxx/thread.cpp
View File

@@ -39,11 +39,11 @@
#include <rtems.h>
#if HAVE_GET_SCHEDULER_NAME
extern "C" bool get_scheduler_name (rtems_id sid, char* name);
extern "C" bool get_scheduler_name(rtems_id sid, char* name);
#endif
#if HAVE_GET_SCHEDULER_NAME
bool get_scheduler_name (rtems_id sid, char* name)
bool get_scheduler_name(rtems_id sid, char* name)
{
name[0] = 'N';
name[1] = 'O';
@@ -58,58 +58,58 @@ namespace rtems
namespace thread
{
void
system_error_check (int ec, const char* what)
system_error_check(int ec, const char* what)
{
if (ec != 0) {
throw std::system_error (ec, std::system_category(), what);
throw std::system_error(ec, std::system_category(), what);
}
}
attributes::attributes ()
: priority (-1),
stack_size (RTEMS_MINIMUM_STACK_SIZE),
attr (sched_inherit),
policy (sched_fifo)
attributes::attributes()
: priority(-1),
stack_size(RTEMS_MINIMUM_STACK_SIZE),
attr(sched_inherit),
policy(sched_fifo)
{
update ();
update();
}
attributes::attributes (const attributes& attr)
: name (attr.name),
priority (attr.priority),
stack_size (attr.stack_size),
scheduler (attr.scheduler),
attr (attr.attr),
policy (attr.policy)
attributes::attributes(const attributes& attr)
: name(attr.name),
priority(attr.priority),
stack_size(attr.stack_size),
scheduler(attr.scheduler),
attr(attr.attr),
policy(attr.policy)
{
}
void
attributes::set_name (const std::string& name_)
attributes::set_name(const std::string& name_)
{
name = name_;
}
void
attributes::set_name (const char* name_)
attributes::set_name(const char* name_)
{
name = name_;
}
const std::string&
attributes::get_name () const
attributes::get_name() const
{
return name;
}
void
attributes::set_priority (int priority_)
attributes::set_priority(int priority_)
{
priority = priority_;
}
int
attributes::get_priority () const
attributes::get_priority() const
{
return priority;
}
@@ -121,63 +121,63 @@ namespace rtems
}
size_t
attributes::get_stack_size () const
attributes::get_stack_size() const
{
return stack_size;
}
void
attributes::set_scheduler (const std::string& scheduler_)
attributes::set_scheduler(const std::string& scheduler_)
{
scheduler = scheduler_;
}
void
attributes::set_scheduler (const char* scheduler_)
attributes::set_scheduler(const char* scheduler_)
{
scheduler = scheduler_;
}
const std::string&
attributes::get_scheduler ()
attributes::get_scheduler()
{
return scheduler;
}
attributes::sched_attr
attributes::get_scheduler_attr () const
attributes::get_scheduler_attr() const
{
return attr;
}
void
attributes::set_scheduler_policy (sched_policy policy_)
attributes::set_scheduler_policy(sched_policy policy_)
{
attr = sched_explicit;
policy = policy_;
}
attributes::sched_policy
attributes::get_scheduler_policy () const
attributes::get_scheduler_policy() const
{
return policy;
}
void
attributes::commit ()
attributes::commit()
{
pthread_t pid = ::pthread_self ();
pthread_t pid = ::pthread_self();
system_error_check (::pthread_setname_np (pid, name.c_str ()),
"getting name");
system_error_check(::pthread_setname_np(pid, name.c_str()),
"getting name");
int spolicy;
struct sched_param sched_param;
system_error_check (::pthread_getschedparam (::pthread_self (),
&spolicy,
&sched_param),
"getting scheduler parameters");
system_error_check(::pthread_getschedparam(::pthread_self(),
&spolicy,
&sched_param),
"getting scheduler parameters");
switch (policy) {
case sched_other:
@@ -193,33 +193,33 @@ namespace rtems
spolicy = SCHED_SPORADIC;
break;
default:
system_error_check (EINVAL, "get scheduler policy");
system_error_check(EINVAL, "get scheduler policy");
break;
}
sched_param.sched_priority = priority;
system_error_check (::pthread_setschedparam (::pthread_self (),
spolicy,
&sched_param),
"getting scheduler parameters");
system_error_check(::pthread_setschedparam(::pthread_self(),
spolicy,
&sched_param),
"getting scheduler parameters");
if (!scheduler.empty ()) {
if (!scheduler.empty()) {
char sname[4] = { ' ', ' ', ' ', ' ' };
for (size_t c = 0; c < sizeof (sname); ++c) {
if (c >= scheduler.length ()) {
for (size_t c = 0; c < sizeof(sname); ++c) {
if (c >= scheduler.length()) {
break;
}
sname[c] = scheduler[c];
}
rtems_name scheduler_name = rtems_build_name (sname[0],
sname[1],
sname[2],
sname[3]);
rtems_name scheduler_name = rtems_build_name(sname[0],
sname[1],
sname[2],
sname[3]);
rtems_id scheduler_id;
runtime_error_check (::rtems_scheduler_ident (scheduler_name,
&scheduler_id),
"get scheduler id");
runtime_error_check(::rtems_scheduler_ident(scheduler_name,
&scheduler_id),
"get scheduler id");
// runtime_error_check (::rtems_task_set_scheduler (RTEMS_SELF,
// scheduler_id,
// 1),
@@ -228,21 +228,21 @@ namespace rtems
}
void
attributes::update ()
attributes::update()
{
char buf[32];
system_error_check (::pthread_getname_np (::pthread_self (),
buf,
sizeof (buf)),
"getting name");
system_error_check(::pthread_getname_np(::pthread_self(),
buf,
sizeof (buf)),
"getting name");
name = buf;
int spolicy;
struct sched_param sched_param;
system_error_check (::pthread_getschedparam (::pthread_self (),
&spolicy,
&sched_param),
"getting scheduler parameters");
system_error_check(::pthread_getschedparam(::pthread_self(),
&spolicy,
&sched_param),
"getting scheduler parameters");
switch (spolicy) {
case SCHED_OTHER:
@@ -258,19 +258,19 @@ namespace rtems
policy = sched_sporadic;
break;
default:
system_error_check (EINVAL, "get scheduler policy");
system_error_check(EINVAL, "get scheduler policy");
break;
}
priority = sched_param.sched_priority;
pthread_attr_t pattr;
system_error_check (::pthread_getattr_np (::pthread_self (), &pattr),
"getting thread attributes");
system_error_check (::pthread_attr_getstacksize (&pattr, &stack_size),
"getting stack size");
system_error_check(::pthread_getattr_np(::pthread_self(), &pattr),
"getting thread attributes");
system_error_check(::pthread_attr_getstacksize(&pattr, &stack_size),
"getting stack size");
int inheritsched = 0;
system_error_check (::pthread_attr_getinheritsched (&pattr, &inheritsched),
"getting inherited sheduler attribute");
system_error_check(::pthread_attr_getinheritsched(&pattr, &inheritsched),
"getting inherited sheduler attribute");
switch (inheritsched) {
case PTHREAD_INHERIT_SCHED:
attr = sched_inherit;
@@ -279,23 +279,23 @@ namespace rtems
attr = sched_explicit;
break;
default:
system_error_check (EINVAL, "get scheduler attribute");
system_error_check(EINVAL, "get scheduler attribute");
break;
}
rtems_id scheduler_id;
runtime_error_check (::rtems_task_get_scheduler (RTEMS_SELF, &scheduler_id));
runtime_error_check(::rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id));
#if HAVE_GET_SCHEDULER_NAME
char name[5];
if (!get_scheduler_name (scheduler_id, &name[0])) {
system_error_check (ENOENT, "get scheduler name");
if (!get_scheduler_name(scheduler_id, &name[0])) {
system_error_check(ENOENT, "get scheduler name");
}
scheduler = name;
#endif
}
attributes&
attributes::operator= (const attributes& other)
attributes::operator=(const attributes& other)
{
name = other.name;
priority = other.priority;
@@ -306,7 +306,7 @@ namespace rtems
}
bool
attributes::operator== (const attributes& other) const
attributes::operator==(const attributes& other) const
{
return
name == other.name &&
@@ -317,22 +317,22 @@ namespace rtems
}
void*
thread_generic_entry (void* arg)
thread_generic_entry(void* arg)
{
thread::state_ptr s{ static_cast<thread::state_base*> (arg) };
thread::state_ptr s{ static_cast<thread::state_base*>(arg) };
try {
s->run ();
s->run();
} catch (...) {
std::terminate ();
std::terminate();
}
return nullptr;
}
thread&
thread::operator= (thread&& thread_)
thread::operator=(thread&& thread_)
{
if (joinable ()) {
std::terminate ();
if (joinable()) {
std::terminate();
}
swap(thread_);
return *this;
@@ -354,9 +354,9 @@ namespace rtems
thread::join()
{
if (!joinable()) {
system_error_check (EINVAL, "join");
system_error_check(EINVAL, "join");
}
system_error_check (::pthread_join (id_.id_, nullptr), "join");
system_error_check(::pthread_join(id_.id_, nullptr), "join");
id_ = id();
}
@@ -364,31 +364,31 @@ namespace rtems
thread::detach()
{
if (!joinable()) {
system_error_check (EINVAL, "detach");
system_error_check(EINVAL, "detach");
}
system_error_check (::pthread_detach (id_.id_), "detach");
system_error_check(::pthread_detach(id_.id_), "detach");
id_ = id();
}
thread::state_base::~state_base () = default;
thread::state_base::~state_base() = default;
void
thread::start_thread (thread::state_ptr s)
thread::start_thread(thread::state_ptr s)
{
const attributes attr = s->get_attributes ();
const attributes attr = s->get_attributes();
pthread_attr_t pattr;
system_error_check (::pthread_attr_init (&pattr),
"attribute init");
system_error_check(::pthread_attr_init(&pattr),
"attribute init");
struct sched_param param;
param.sched_priority = attr.get_priority ();
system_error_check (::pthread_attr_setschedparam (&pattr, &param),
"set sched param");
param.sched_priority = attr.get_priority();
system_error_check(::pthread_attr_setschedparam(&pattr, &param),
"set sched param");
int spolicy;
switch (attr.get_scheduler_policy ()) {
switch (attr.get_scheduler_policy()) {
case attributes::sched_other:
spolicy = SCHED_OTHER;
break;
@@ -402,37 +402,37 @@ namespace rtems
spolicy = SCHED_FIFO;
break;
}
system_error_check (::pthread_attr_setschedpolicy (&pattr, spolicy),
"set scheduler policy");
system_error_check(::pthread_attr_setschedpolicy(&pattr, spolicy),
"set scheduler policy");
if (attr.get_scheduler_attr () == attributes::sched_inherit) {
::pthread_attr_setinheritsched (&pattr, PTHREAD_INHERIT_SCHED);
if (attr.get_scheduler_attr() == attributes::sched_inherit) {
::pthread_attr_setinheritsched(&pattr, PTHREAD_INHERIT_SCHED);
}
else {
::pthread_attr_setinheritsched (&pattr, PTHREAD_EXPLICIT_SCHED);
::pthread_attr_setinheritsched(&pattr, PTHREAD_EXPLICIT_SCHED);
}
system_error_check (::pthread_attr_setstacksize(&pattr,
attr.get_stack_size ()),
"set stack size");
system_error_check(::pthread_attr_setstacksize(&pattr,
attr.get_stack_size()),
"set stack size");
/*
* Hold the new thread in the state's run handler until the rest
* of the thread is set up after the create call.
*/
system_error_check (::pthread_create (&id_.id_,
&pattr,
thread_generic_entry,
s.get ()),
"create thread");
system_error_check(::pthread_create(&id_.id_,
&pattr,
thread_generic_entry,
s.get()),
"create thread");
system_error_check (::pthread_setname_np (id_.id_,
attr.get_name ().c_str ()),
"setting thread name");
system_error_check(::pthread_setname_np(id_.id_,
attr.get_name().c_str()),
"setting thread name");
::pthread_attr_destroy (&pattr);
::pthread_attr_destroy(&pattr);
s.release ();
s.release();
};
};
};