OpenMP reduction with overloaded operator

c++, openmp, operator-overloading, parallel-processing

Solution

It's true that OpenMP reduction can't handle such overloaded operators. However, there is an alternative. One way to rewrite a reduction in OpenMP is to use the `nowait` and `atomic` paramters. http://bisqwit.iki.fi/story/howto/openmp/#ReductionClause .This is just as fast as the normal way.

If you replace `atomic` with `critical` you can use more complex overloaded operators. This is not as fast as using `atomic` but it's still works well in my experience.

I did this so I could use operators that operate on 4 or 8 floats at once (with SEE or AVX). reduction with OpenMP with SSE/AVX

Edit: I changed your code to reflect what I think would do what you want.

void CEnergymulti::forcetwobody(vector<CMolecule*>  m_mols,CPnt force0,CPnt torque0)
{
    const int nmol=m_mols.size();
    force0.zero();
    torque0.zero();
    #pragma omp parallel
    {
        CPnt force0_private;
        CPnt torque0_private; 
        force0_private.clear();
        torque0_private.clear();
        #pragma omp for nowait
        for(int j=1;j<nmol;j++)
        { 
            CPnt forcetemp,torquetemp;
            forcetemp.zero();
            torquetemp.zero();
            vector<CMolecule*> twomols(2);
            twomols.clear();
            twomols.push_back(m_mols[0]);
            twomols.push_back(m_mols[j]);
            CMolecule::polarize_mutual(twomols,false, 1000);
            twomols[0]->computeMol_Force_and_Torque(forcetemp,torquetemp);
            force0_private+=forcetemp;
            torque0_private+=torquetemp;
        }
        #pragma omp critical 
        {
           force0 += force0_private;
           torque0 += torque0_private;
        }

    }
    REAL converter=COUL_K*IKbT;
    force0*=converter;
    torque0*=converter;
    return;
}

Problem

Original source