Re: [Boost-users] OpenMP and Boost - can they be used together?

16 Sep 2010

      I fixed the problem... basically, entries of a double array get
rounded when summed, and the order in which the sum is performed
matters, so the final answer might differ by some small number due to
rounding. Using an "ordered" directive fixes this. If anyone else is
having this issue, here is sample code, see the comment in the code
about the for loop.

Also, notice how the reduction clause is used and how the sum variable
is no longer shared - that was another issue with the code.

#include <iostream>
#include 
#include 
#include 

#define ENABLE_OPENMP_SCORE 1
#define N 100
#define NUMTHREADS 32

using std::cout;
using std::endl;
using boost::numeric::ublas::matrix;

class Compute {
  matrix<double> data1;

public:
  Compute() {
    data1 = matrix<double> (N, N);
    for (unsigned i = 0; i < N; ++i)
      for (unsigned j = 0; j < N; ++j)
        //data1(i, j) = i * N + j;
        data1(i, j) = 1.0/(i * N + j + 1.0);
  }

  double compute_score() {

    double sc = 0.0;
    unsigned i, j;

#pragma omp parallel \
  private(i,j) \
  reduction(+:sc) \
  if (ENABLE_OPENMP_SCORE)
    {
      omp_set_num_threads(NUMTHREADS);

/* Use the line below - it works, because the loop interations are ordered. */
//#pragma omp for ordered schedule(static) collapse(2) nowait
/* This line does not have an "ordered" directive, so the loop
iterations are performed in any order, and due to rounding, the sum is
slightly different each time. */
#pragma omp for schedule(static) collapse(2) nowait
      for (i = 0; i < N; ++i) {
        for (j = 0; j < N; ++j) {
          sc += data1(i, j);
        }
      }
    }
    //cout << data1 << endl;
    return sc;
  }
};

int main(void) {

  Compute comp;

  double oldval = comp.compute_score(), newval;
  cout.precision(32);
  cout << "--" << endl;
  while (1) {
    newval = comp.compute_score();
    cout << "--" << endl;
    if (newval != oldval) {
      cout << " newval - oldval = diff, " << newval << " - " << oldval << " = "
          << newval - oldval << endl;
      exit(1);
    }
    oldval = newval;
  }

  return 0;
}

On Wed, Sep 15, 2010 at 11:42 PM, dhruva  wrote:
...
Hi,
 With my limited knowledge of OpenMP, I am attempting to give some hints.
On Thu, Sep 16, 2010 at 5:04 AM, Max S. Kaznady  wrote:
...
Hello,
I wrote a simple parallel program which computes the sum of elements
across a matrix using Boost. When I use OpenMP, the program runs give
different sums. When I use just simple arrays like double array[N][N],
instead of boost::numeric::ublas::matrix<double>, the code work just
fine and as expected. Does anyone know what is going on? It looks like
the score function is not being modified properly, because Boost array
returns just fine.
...
[code]
 double sc = 0.0;
 unsigned i, j;
 matrix<double> temp(N, N);
#pragma omp parallel \
 shared(sc,temp) \
Not sure if you can share a user defined type which does not point to
a contiguous
block of memory. Could you please try using a normal array instead of
boost array
only for 'temp' and see what happens. I am doubting race conditions since OpenMP
cannot guarantee synchronous write access to 'temp' IIRC using memory barriers.
-dhruva
_______________________________________________
Boost-users mailing list
Boost-users@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users