[Omp] A question about OpenMP 2.5

[Dieter an Mey]

Dear  all,

I don't think that the question was related to the OpenMP memory model, 
but to the wording and understanding of the current OpenMP specification.

Brad looked at a perfectly legal piece of code
(I slightly modified it using default(none) etc.)
 >     void a1(int n, float *a, float *b)
 >     {
 >         int i;
 >     #pragma omp parallel for default(none) shared(a,b) private(i,n)
 >         for (i=1; i<n; i++) /* i is private by default */
 >             b[i] = (a[i] + a[i-1]) / 2.0;
 >     }

and thinks that when reading the specs, the result of this loop shall be 
undefined.

As the pointers a and b can be put in scoping clauses those are 
variables in the OpenMP terminology.

Now to the question:

 > 1. As I understand the parallel command above, different threads may
 > execute the loop for different values of i.

yes.

 > 2. As I understand, the variable b is a shared variable because it is
 > defined before the loop.

yes.

 > 3. The arguments b to the routine a1 may be an array, for example
 > it may be declared in the calling program by
 >     float b[SIZE];
 > where SIZE is any positive integer constant greater than or equal n.

yes.

 > 4. In the case of 3 above, b is a variable, and b[i] is not a variable,

true.

 > hence multiple threads may be writing to the same variable; namely b.

wrong:
if the memory regions to which a and b are pointing to do not overlap 
(aliasing) multiple threads are writing to different memory locations 
and not to the same variable as b[i] is not a variable.
This is not related to atomicity etc.

 >
 > 5. Thus, in the case described above, the result of the loop is 
undefined.

wrong.

Anyway, it seems to me that the specification should be corrected to say 
something like

  >    If multiple threads write to the same ** memory location **
  >    without synchronization, the resulting ** memory content **
  >    is unspecified. If at least one thread reads from
  >    a shared ** memory location ** and at least one thread writes to
  >    it without
  >    synchronization, the value seen by any reading thread is
  >    unspecified.

This text just describes the circumstances of a data race.

regards
Dieter
 >

Brad Bell schrieb:
> I have a question about the OpenMP 2.5 standard
>     http://www.openmp.org/drupal/mp-documents/spec25.pdf
> 
> In Section 1.2.3 Data Terminology of spec25.pdf,
> the following text appears:
> 
>    variable
>    A named data object, whose value can be defined and
>    redefined during the execution of a program.
> 
>    Only an object that is not part of another object is
>    considered a variable. For example, array elements,
>    structure components, array sections and substrings
>    are not considered variables.
> 
> 
> In Section 1.4.1 Structure of the OpenMP Memory Model of spec25.pdf,
> the following text appears:
> 
>    If multiple threads write to the same shared variable
>    without synchronization, the resulting value of the variable
>    in memory is unspecified. If at least one thread reads from
>    a shared variable and at least one thread writes to it without
>    synchronization, the value seen by any reading thread is unspecified.
> 
> It appears to me that, given the text above, that Example A.1.1.c of
> in the OpenMP 2.5 standard is not correct (or at least misleading).
> Here is the code for that example:
>     
>     void a1(int n, float *a, float *b)
>     {
>         int i;
>     #pragma omp parallel for
>         for (i=1; i<n; i++) /* i is private by default */
>             b[i] = (a[i] + a[i-1]) / 2.0;
>     }
> 
> 1. As I understand the parallel command above, different threads may 
> execute
> the loop for different values of i.
> 
> 2. As I understand, the variable b is a shared variable because it is
> defined before the loop.
> 
> 3. The arguments b to the routine a1 may be an array, for example
> it may be declared in the calling program by
>     float b[SIZE];
> where SIZE is any positive integer constant greater than or equal n.
> 
> 4. In the case of 3 above, b is a variable, and b[i] is not a variable,
> hence multiple threads may be writing to the same variable; namely b.
> 
> 5. Thus, in the case described above, the result of the loop is undefined.
> 
> 
> 
> _______________________________________________
> Omp mailing list
> Omp at openmp.org
> http://openmp.org/mailman/listinfo/omp
> 

-- 
--------------------------------------------------------------------
Dieter an Mey
High Performance Computing               Hochleistungsrechnen
RWTH Aachen University                   Rechen- und Kommunikations-
Center for Computing and Communication   zentrum der RWTH Aachen
phone: ++49-(0)241-80-24377              Seffenter Weg 23
fax:   ++49-(0)241-80-22134              52074 Aachen, Germany
email: anmey at rz.rwth-aachen.de
--------------------------------------------------------------------