Re: Threads: incompatibilities between C and C++?
On May 14, 10:14 pm, Pete Becker <p...@versatilecoding.com> wrote:
The difference in the signatures of the called functions comes about
because thrd_create takes a function pointer of type int(*)(void*); in
C++, the std::thread constructor takes an arbitrary callable type and
an appropriate argument list.
This isn't properly called "an incompatibility", however. The
underlying design models are quite different.
I also noticed a potential abstraction penalty associated with
std::thread.
Per the C++ standard 30.3.1.2/4 (thread construction):
The *new thread of execution executes* INVOKE(DECAY_-
COPY( std::forward<F>(f)), DECAY_COPY (std::forward<Args>(args))...)
with the calls to DECAY_COPY being evaluated in the constructing
thread.
This means that in general the caller thread has to wait for the new
thread copying - serialization penalty that doesn't exist for the raw
C interface. I guess that the requirement (feature) is meant to allow
TLS sensitive copying or some sort of transfer-of-ownership though I
can't think about any realistic use case relaying on such feature.
I already noticed that the VC implementation is taking the penalty for
every call including when passing raw-pointers or lambda.
Thread pools with similar interface might have the same problem (which
is more severe for pools).
Example for why the wait is needed:
struct A {};
void func(A&) {}
void f()
{
A a = {};
// copy of 'a' is done by the new thread
// hence f() has to wait to keep the source alive
std::thread(func, a);
}
Rani
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]