Factors in TTI and general case

[mloubout]

@pvelesko @navjotk
I found the problem with instability in TTI. It was not a precision issue, but a missing private statement with openmp. I currenly hard coded it by hand to be able to run tests, but this needs to be fixed in propagator. The constant factors (and the same will apply for CSE constants) have to be declared private in the omp environment.

[FabioLuporini]

I'm not sure I understand. The CSE expressions, as you correctly say, should be constants, so why should they be declared private ?

I am now also confused about the semantics of these factors. I thought they were just "temporaries" that you manually identified and extracted from the equation. Could you paste here (or point us to) a full code snippet ?

Thanks

[mloubout]

Even if it is a "constant" meaning a scalar value, this value is spacially dependent, and if not declared as private, each thread may work with a wrong value of this constant, If it was an actual constant it would not be computed within the loops but at the very beginning of the function.

[FabioLuporini]

Ah, so you're saying that we are in a situation like

temporaries = ...
#pragma omp parallel
{
    // use temporaries here
}

Meaning that the space for the temporaries are allocated outside of the parallel region ? Because otherwise I thought variables are automatically private if defined within a parallel region

[mloubout]

It is done

float temporary
#pragma omp parallel
{
    temporary = something(x,y,z)
    // use temporaries here
}

so yes it is allocated outside and therefor shared by default

[FabioLuporini]

OK, I see

[ggorman]

The approach I am advocating is

#pragma omp parallel
{
    float temporary = something(x,y,z)
    // use temporaries here
}```
so scope becomes explicit without pragma parameters.

[FabioLuporini]

Ah, question (this maybe doesn't happen in our code, but just to be sure...)

If what we allocate outside of the parallel region is a multi-dimensional array, and then we declare it as private, is it possible that we end up with allocating extra, useless memory?

[mloubout]

Yes it would, but this is indeed not our case.
In our case, all multi-dimensional array are either read only or with independent write indexing (each thread updates a different part of the array that can't overlap). So it shouldn't be a problem for us as we can leave this arrays shared.

[mloubout]

Just pointing out that this issue is still in master, it only passes TRAVIS because it runs singlethreaded.

[sheino]

Fixed in CSE