Reducing on array in OpenMP

by

Yes it is possible to do an array reduction with OpenMP. In Fortran it even has construct for this. In C/C++ you have to do it yourself. Here are two ways to do it.

The first method makes private version of S for each thread, fill them in parallel, and then merges them into S in a critical section (see the code below). The second method makes an array with dimentions 10*nthreads. Fills this array in parallel and then merges it into S without using a critical section. The second method is much more complicated and can have cache issues especially on multi-socket systems if you are not careful. For more details see this Fill histograms (array reduction) in parallel with OpenMP without using a critical section

First method

int A [] = {84, 30, 95, 94, 36, 73, 52, 23, 2, 13};
int S [10] = {0};
#pragma omp parallel
{
    int S_private[10] = {0};
    #pragma omp for
    for (int n=0 ; n<10 ; ++n ) {
        for (int m=0; m<=n; ++m){
            S_private[n] += A[m];
        }
    }
    #pragma omp critical
    {
        for(int n=0; n<10; ++n) {
            S[n] += S_private[n];
        }
    }
}

Second method

int A [] = {84, 30, 95, 94, 36, 73, 52, 23, 2, 13};
int S [10] = {0};
int *S_private;
#pragma omp parallel
{
    const int nthreads = omp_get_num_threads();
    const int ithread = omp_get_thread_num();

    #pragma omp single 
    {
        S_private = new int[10*nthreads];
        for(int i=0; i<(10*nthreads); i++) S_private[i] = 0;
    }
    #pragma omp for
    for (int n=0 ; n<10 ; ++n )
    {
        for (int m=0; m<=n; ++m){
            S_private[ithread*10+n] += A[m];
        }
    }
    #pragma omp for
    for(int i=0; i<10; i++) {
        for(int t=0; t<nthreads; t++) {
            S[i] += S_private[10*t + i];
        }
    }
}
delete[] S_private;

More Related Contents:

  1. OpenMP: What is the benefit of nesting parallelizations?
  2. Why is the != operator not allowed with OpenMP?
  3. Concurrency: Atomic and volatile in C++11 memory model
  4. How does the omp ordered clause work?
  5. What’s the difference between “static” and “dynamic” schedule in OpenMP?
  6. Mixing C++11 atomics and OpenMP
  7. Measure execution time in C++ OpenMP code
  8. OpenMP set_num_threads() is not working
  9. How does OpenMP handle nested loops?
  10. openMP nested parallel for loops vs inner parallel for
  11. When to use volatile with multi threading?
  12. Is Meyers’ implementation of the Singleton pattern thread safe?
  13. How do I terminate a thread in C++11?
  14. C++: Simple return value from std::thread?
  15. Difference between section and task openmp
  16. Measuring memory bandwidth from the dot product of two arrays
  17. How to use std::async on a member function?
  18. C++0x thread interruption
  19. Acquire/release semantics with non-temporal stores on x64
  20. Is volatile bool for thread control considered wrong?
  21. How to easily make std::cout thread-safe?
  22. How to use lock in OpenMP?
  23. What is different between join() and detach() for multi threading in C++?
  24. std::thread error (thread not member of std)
  25. Does std::mutex create a fence?
  26. Should thread-safe class have a memory barrier at the end of its constructor?
  27. ReleaseSemaphore does not release the semaphore
  28. C++11 std::threads vs posix threads
  29. Are C/C++ fundamental types atomic?
  30. How do I guarantee fast shutdown of my win32 app?

Leave a Comment