C++11 Thread safety of Random number generators

by

The C++11 standard library is broadly thread safe. The thread safety guarantees on PRNG objects are the same as on containers. More specifically, since the PRNG classes are all pseudo-random, i.e. they generate a deterministic sequence based on a definite current state, there is really no room to be peeking or poking at anything outside the contained state (which is also visible to the user).

Just as containers need locks to make them safe to share, you would have to lock the PRNG object. This would make it slow and nondeterministic. One object per thread would be better.

§17.6.5.9 [res.on.data.races]:

1 This section specifies requirements that implementations shall meet
to prevent data races (1.10). Every standard library function shall
meet each requirement unless otherwise specified. Implementations may
prevent data races in cases other than those specified below.

2 A C++ standard library function shall not directly or indirectly
access objects (1.10) accessible by threads other than the current
thread unless the objects are accessed directly or indirectly via the
function’s argu- ments, including this.

3 A C++ standard library function shall not directly or indirectly
modify objects (1.10) accessible by threads other than the current
thread unless the objects are accessed directly or indirectly via the
function’s non- const arguments, including this.

4 [ Note: This means, for example, that implementations can’t use a
static object for internal purposes without synchronization because it
could cause a data race even in programs that do not explicitly share
objects betweenthreads. —endnote]

5 A C++ standard library function shall not access objects indirectly
accessible via its arguments or via elements of its container
arguments except by invoking functions required by its specification
on those container elements.

6 Operations on iterators obtained by calling a standard library
container or string member function may access the underlying
container, but shall not modify it. [Note: In particular, container
operations that invalidate iterators conflict with operations on
iterators associated with that container. — end note ]

7 Implementations may share their own internal objects between threads
if the objects are not visible to users and are protected against data
races.

8 Unless otherwise specified, C++ standard library functions shall
perform all operations solely within the current thread if those
operations have effects that are visible (1.10) to users.

9 [ Note: This allows implementations to parallelize operations if
there are no visible side effects. — end note ]

More Related Contents:

  1. Is local static variable initialization thread-safe in C++11? [duplicate]
  2. Does const mean thread-safe in C++11?
  3. Mixing C++11 atomics and OpenMP
  4. What do each memory_order mean?
  5. Can I safely use OpenMP with C++11?
  6. thread safety of MPI send using threads created with std::async
  7. Using generic std::function objects with member functions in one class
  8. Reusing a moved container?
  9. C++0x lambda capture by value always const?
  10. ‘colon’ and ‘auto’ in for loop c++? need some help understanding the syntax
  11. Computing length of a C string at compile time. Is this really a constexpr?
  12. Detecting constexpr with SFINAE
  13. Does moving leave the object in a usable state?
  14. Copy constructor is not inherited
  15. C++11 lambda implementation and memory model
  16. How to construct std::array object with initializer list? [duplicate]
  17. C++11: Compile Time Calculation of Array
  18. Is it possible to initialize std::vector over already allocated memory?
  19. Why do auto and template type deduction differ for braced initializers?
  20. Forwarding all constructors in C++0x
  21. What expressions yield a reference type when decltype is applied to them?
  22. How can I have multiple parameter packs in a variadic template?
  23. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  24. Is boost shared_ptr thread safe?
  25. When is std::chrono epoch?
  26. What am I allowed to do with a static, constexpr, in-class initialized data member?
  27. What is the purpose of std::function and how to use it?
  28. const auto std::initializer_list difference between Clang and GCC
  29. Why is the != operator not allowed with OpenMP?
  30. Overload resolution with ref-qualifiers

Leave a Comment