Paralell domain: signals doesn't seem to parallelize

[klaufir]

Probably I misunderstand how parallelizing signals should be done. My issue is that the code below doesn't seem to parallelize. It is the example code from the README. As for the doCostlyOperation, it just sleeps for 1 second.

#include <cmath>
#include <functional>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

#if defined(WIN32)
#include <windows.h>
#elif !defined(WIN32)
#include <unistd.h>
void Sleep(int ms) {
    usleep(1000*ms);
}
#endif

#include <react/Domain.h>
#include <react/Signal.h>
#include <react/Observer.h>


using namespace std;
using namespace react;

REACTIVE_DOMAIN(D, parallel)
USING_REACTIVE_DOMAIN(D)

int doCostlyOperation(int in) {
    std::cout << "do  " << in << std::endl;
    Sleep(1000);
    std::cout << "end " << in << std::endl;

    return in;
}

VarSignalT<int> in = MakeVar<D>(0);

SignalT<int> op1 = MakeSignal(in,
    [] (int in) {
        return doCostlyOperation(in);
    });

SignalT<int> op2 = MakeSignal(in,
    [] (int in) {
        return doCostlyOperation(in);
    });

// op1 and op2 can be re-calculated in parallel
SignalT<int> out = op1 + op2;


int main()
{
    in <<= 2;
}

The output I get is this:

do  0
end 0
do  0
end 0
do  2
end 2
do  2
end 2

Sleeps happen here:

do  0 # after this line  
end 0
do  0 # after this line
end 0
do  2 # after this line
end 2
do  2 # after this line
end 2

I would expect the code above to do some of the tasks in parallel, but currently it acts as if it were sequential.

[klaufir]

Versions

CppReact: latest git
TBB 4.2~20130725
Boost 1.57
Gcc 4.9
OS: Ubuntu 14.04

[schlangster]

Thanks for the report. The observation that the code is executed sequentially is correct. But if you do

int main()
{
    in <<= 2; // sequential
    in <<= 4; // parallel
}

The second operation (and all further ones) will be parallel.

The reason is that there are certain optimizations employed to automatically detect trivial operations and chunk them together. To be able to do that, the engine has to measure the execution time of an update first. That happens during in <<= 2. After that op1 and op2 will be flagged as heavyweight and parallelized.

What you can do at the moment is the following:

    op1.SetWeightHint(WeightHint::heavy);
    op2.SetWeightHint(WeightHint::heavy);
    in <<= 2; //parallel

That will override the automatic node weight detection.

I do acknowledge that this is not optimal yet. It would probably be better for parallel engines to have a "parallel by default, fallback to sequential" policy rather than the other way around. The cost of unnecessary parallelization is nothing compared to running costly operations sequentially.