Gain from threading much less than expected - why?

Question

I have a function evaluation which is somewhat slow. I'm trying to speed it up by using threading, since there are three things which can be done in parallel. The single-threaded version is

return dEdx_short(E) + dEdx_long(E) + dEdx_quantum(E);

where evaluation of those functions takes ~250us, ~250us, and ~100us respectively. So I implemented a three-thread solution:

double ret_short, ret_long, ret_quantum; // return values for the terms

auto shortF = [this,&E,&ret_short] () {ret_short = this->dEdx_short(E);};
std::thread t1(shortF);
auto longF = [this,&E,&ret_long] () {ret_long = this->dEdx_long(E);};
std::thread t2(longF);
auto quantumF = [this,&E,&ret_quantum] () {ret_quantum = this->dEdx_quantum(E);};
std::thread t3(quantumF);

t1.join();
t2.join();
t3.join();

return ret_short + ret_long + ret_quantum;

Which I expected to take ~300us, yet it actually takes ~600us - basically the same as the single-threaded version! These are all inherently thread-safe so there are no waits for locks. I checked the thread creation time on my system and it's ~25us. I'm not using all of my cores, so I'm a bit baffled as to why the parallel solution is so slow. Is it something to do with the lambda creation?

I tried to bypass the lambda, e.g.:

std::thread t1(&StopPow_BPS::dEdx_short, this, E, ret_short);

after rewriting the function being called, but that gave me an error attempt to use a deleted function...

Answer 1

Perhaps you are experiencing false sharing. To verify, store the return values in a type that uses an entire cache line (size depends on CPU).

const int cacheLineSize = 64; // bytes
union CacheFriendly
{
    double value;
    char dummy[cacheLineSize];
} ret_short, ret_long, ret_quantum; // return values for the terms
// ...