用openmp并行计算循环

Question

I have an 2d-image where I want to count all colors and store the result in an array. I know the number of colors, so I can set the size of the array before. My problem now is that the counting lasts too long for me. How can I speed the counting up with OpenMP?
My current serial code is

std::vector<int> ref_color_num_thread;
    ref_color_num.resize(ref_color.size());
    std::fill(ref_color_num.begin(), ref_color_num.end(), 0);
    ref_color_num_thread.resize(ref_color.size());
    std::fill(ref_color_num_thread.begin(), ref_color_num_thread.end(), 0);

    for (int i = 0; i < image.width(); i++)
    {
        for (int j = 0; j < image.height(); j++)
        {
            for (int k = 0; k < (int)ref_color.size(); k++)
            {
                if (image(i, j, 0, 0) == ref_color[k].R && image(i, j, 0, 1) == ref_color[k].G && image(i, j, 0, 2) == ref_color[k].B)
                    ref_color_num_thread[k]++;
            }
        }
    }

First approaches were setting #pragma omp parallel for at each loop (each try at another), but everytime I get a program crash because of wrong memory access. Do I have to use private() for my vector?

Answer 1

What you're doing is filling a histogram of your colors. This is equivalence to doing an array reduction in C/C++ with OpenMP. In C/C++ OpenMP does not have built in support for this (but it does in Fortran due to the fact that the array size is known in Fortran where in C/C++ it's only known for static arrays). However, it's easy to do an array reduction in C/C++ with OpenMP yourself.

#pragma omp parallel 
{
    std:vector<int> ref_color_num_thread_private(ref_color.size(),0);
    #pragma omp for
    for (int i = 0; i < image.width(); i++) {
        for (int j = 0; j < image.height(); j++) {
            for (int k = 0; k < (int)ref_color.size(); k++) {
                if (image(i, j, 0, 0) == ref_color[k].R && image(i, j, 0, 1) == ref_color[k].G && image(i, j, 0, 2) == ref_color[k].B) 
                    ref_color_num_thread_private[k]++;
            }
        }
    }
    #pragma omp critical 
    {   
        for(int i=0; i<(int)ref_color.size(); i++) {
             ref_color_num_thread[i] += ref_color_num_thread_private[i];
        }
    }
}

I went into a lot more detail about his here Fill histograms (array reduction) in parallel with OpenMP without using a critical section

I showed how to an array reduction without a critical section but it's a lot more tricky. You should test the first case and see if it works well for you first. As long as the number of colors (ref_color.size()) is small compared to the number of pixels it should parallelize well. Otherwise, you might need to try the second case without a critical section.

Answer 2

There is a race condition if one of the outer two loops (i or j) are parallized, because the inner loop iteratates over the vector (k). I think your crash is because of that.

You have to restructure your program. It is not trivial, but one idea is that each thread uses a local copy of the ref_color_num_thread vector. Once the computation is finished, you can sum up all the vectors.

If k is large enough to provide enough parallelism, you could exchange the loops. Instead of "i,j,k" you could iterate in the order "k,i,j". If I'm not mistaken, there are no violated dependencies. Then you can parallelize the outer k loop, and let the inner i and j loops execute sequentially.

Update:

pragma omp for also supports reductions, for example:

#pragma omp for reduction(+ : nSum)

Here is a link to some documentation .

Maybe that can help you to restructure your program.