Question

I would like to do some transformation to the IplImage using OpenMP. It is simple transformation that turns image upside down. The code with OpenMP runs the same as without. It doesn’t really matter.

void UpsideDownFilter::filter(IplImage* dstImage) {
uchar temp;
int j;
int i;
#pragma omp parallel shared(dstImage) private(j, i, temp)
{
    //        std::cout << omp_get_thread_num() << std::endl;
#pragma omp for schedule(static, 30) nowait
    for(j = 0; j < dstImage->height / 2; ++j) {

        for(i = 0; i < dstImage->widthStep; ++i) {
            temp = dstImage->imageData[i + j * dstImage->widthStep];

            dstImage->imageData[i + j * dstImage->widthStep] =
                dstImage->imageData[i + (dstImage->height - 1 - j) * 
                                    dstImage->widthStep];

            dstImage->imageData[i + (dstImage->height - 1 - j) * 
                                dstImage->widthStep] = temp;
        }
    }
}
}

I’ve already pushed the #pragma omp for to inner loop. I’ve done all the other magic stuff I usually do when I don’t have a clue what’s wrong (delete this, add that). This is how I call that method from my code:

for (vector<filter_ptr>::iterator it = filters.begin();
     it != filters.end(); ++it) {

    (*it)->filter(dstImage);
}

Could anybody tell me what I’m doing wrong?

Answer 1

Since I couldn’t compile your code I wrote my own which I think is pretty similar. You have flattened your 2D matrix and I couldn’t be bothered but I don’t think that will affect what I think is going wrong for you.

#include <vector>

typedef std::vector<std::vector<double> > matrix_t;

void flip(matrix_t& A, int const m, int n)
{
    int m_2 = m / 2;
    #pragma omp parallel for
    for (int i = 0; i < m_2; ++i) {
        for (int j = 0; j < n; ++j) {
            std::swap(A[i][j], A[m - (i + 1)][j]);
        }
    }
}

int
main()
{
    int n = 20000;
    matrix_t A (n, std::vector<double>(n, 1.0));
    flip(A, n, n);
    return 0;
}

On a quad core machine I get no speedup as well.

> g++ -O2 s18.cc && /usr/bin/time ./a.out && g++ -fopenmp -O2 s18.cc && /usr/bin/time ./a.out 
2.61user 2.18system 0:04.79elapsed 99%CPU (0avgtext+0avgdata 12805936maxresident)k
0inputs+0outputs (0major+800428minor)pagefaults 0swaps
7.67user 2.23system 0:04.71elapsed 210%CPU (0avgtext+0avgdata 12806512maxresident)k
0inputs+0outputs (0major+800481minor)pagefaults 0swaps

I think the reason why there is no speedup is because the program is memory bound. That is the speed of the program is controlled by the speed of sending data to and from memory. So no matter how many cores you have you can’t go any faster because they are not the limiting factor.