8

OpenMP, in contrast to C++11, works with atomicity from a perspective of memory operations, not variables. That allows, e.g., to use atomic reads/writes for integers being stored in a vector with unknown size at compile time:

std::vector<int> v;

// non-atomic access (e.g., in a sequential region):
v.resize(n);
...
v.push_back(i);
...

// atomic access in a multi-threaded region:
#pragma omp atomic write // seq_cst
v[k] = ...;
#pragma omp atomic read // seq_cst
... = v[k];

In C++11, this is not possible to achieve. We can kind-of access atomic variables as non-atomic by relaxing memory model, but we cannot resize a vector of atomic elements.

I understand that there are reasons why C++ does not allow to access non-atomic variables by atomic memory operations. But I wonder, why these reasons do not apply for OpenMP as well.

For example, in N4013, it is said that "There is no reasonable way to completely portably apply atomic operations to data not declared as atomic." How it's possible that OpenMP can guarantee such portability and C++ not?

Daniel Langr
  • 22,196
  • 3
  • 50
  • 93
  • 2
    OpenMP doesn't have to be as portable as C++ and the OpenMP implementers on the language community were fine to allow it. I'll try to lookup details later. – Jeff Hammond Feb 28 '16 at 09:31

1 Answers1

2

As far as I understand the respective standards, OpenMP has more restrictions on usage than C++11, which allows it to be portable without using special types. For example, OpenMP 4.5 says:

If the storage location designated by x is not size-aligned (that is, if the byte alignment of x is not a multiple of the size of x), then the behavior of the atomic region is implementation defined.

On the other hand, if C++11 uses std::atomic<int>, then the compiler will guarentee the appropriate alignment. In both cases, alignment is required, but OpenMP and C++11 differ in who is responsible for ensuring this is done.

Generally, there are philosophical differences between OpenMP and C++, but it's hard to enumerate all of them. The C++ folks are thinking about portability to everything, whereas OpenMP is targeted at HPC.

Jeff Hammond
  • 5,374
  • 3
  • 28
  • 45
  • "if C++11 uses std::atomic, then the compiler will guarentee the appropriate alignment." - will it? Where does standard forces this? – osgx Jul 10 '16 at 17:56
  • If I understand things correctly, C++11 ensures atomicity and does not care about alignment. Whether or not the atomicity depends on the proper alignment is an implementation issue (for a given architecture). – Daniel Langr Jul 11 '16 at 07:23
  • It's an implementation issue, but if your hardware can only provide atomicity for aligned words, then your C++ compiler is not able to report std::atomic_is_lock_free unless these types are aligned, so it's going to align them. – Jeff Hammond Jul 11 '16 at 17:26