Multithreading program stuck in optimized mode but runs normally in -O0

by

Two threads, accessing a non-atomic, non-guarded variable are U.B. This concerns finished. You could make finished of type std::atomic<bool> to fix this.

My fix:

#include <iostream>
#include <future>
#include <atomic>

static std::atomic<bool> finished = false;

int func()
{
    size_t i = 0;
    while (!finished)
        ++i;
    return i;
}

int main()
{
    auto result=std::async(std::launch::async, func);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    finished=true;
    std::cout<<"result ="<<result.get();
    std::cout<<"\nmain thread id="<<std::this_thread::get_id()<<std::endl;
}

Output:

result =1023045342
main thread id=140147660588864

Live Demo on coliru

Somebody may think ‘It’s a bool – probably one bit. How can this be non-atomic?’ (I did when I started with multi-threading myself.)

But note that lack-of-tearing is not the only thing that std::atomic gives you. It also makes concurrent read+write access from multiple threads well-defined, stopping the compiler from assuming that re-reading the variable will always see the same value.

Making a bool unguarded, non-atomic can cause additional issues:

  • The compiler might decide to optimize variable into a register or even CSE multiple accesses into one and hoist a load out of a loop.
  • The variable might be cached for a CPU core. (In real life, CPUs have coherent caches. This is not a real problem, but the C++ standard is loose enough to cover hypothetical C++ implementations on non-coherent shared memory where atomic<bool> with memory_order_relaxed store/load would work, but where volatile wouldn’t. Using volatile for this would be UB, even though it works in practice on real C++ implementations.)

To prevent this to happen, the compiler must be told explicitly not to do.

I’m a little bit surprised about the evolving discussion concerning the potential relation of volatile to this issue. Thus, I’d like to spent my two cents:

More Related Contents:

  1. unordered_map thread safety
  2. STL vector and thread-safety
  3. Thread safety of std::map for read-only operations
  4. How to implement a unmanaged thread-safe collection when I get this error: is not supported when compiling with /clr
  5. thread safety of MPI send using threads created with std::async
  6. Threadsafe Vector class for C++
  7. What are all the common undefined behaviours that a C++ programmer should know about? [closed]
  8. When to use volatile with multi threading?
  9. Accessing inactive union member and undefined behavior?
  10. Is Meyers’ implementation of the Singleton pattern thread safe?
  11. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  12. What’s a proper way of type-punning a float to an int and vice-versa?
  13. C++: Simple return value from std::thread?
  14. Are function static variables thread-safe in GCC?
  15. Are multiple mutations within initializer lists undefined behavior?
  16. A C++ implementation that detects undefined behavior?
  17. C++0x thread interruption
  18. Acquire/release semantics with non-temporal stores on x64
  19. Why is it that we can write outside of bounds in C?
  20. Is infinite loop still undefined behavior in C++ if it calls shared library?
  21. Mixing class and struct
  22. Can branches with undefined behavior be assumed unreachable and optimized as dead code?
  23. std::thread error (thread not member of std)
  24. Is stl vector concurrent read thread-safe?
  25. Is Stopwatch.ElapsedTicks threadsafe?
  26. behavior of const_cast in C++ [duplicate]
  27. ReleaseSemaphore does not release the semaphore
  28. Portable Compare And Swap (atomic operations) C/C++ library?
  29. Is it possible to use threads to speed up file reading?
  30. Loading a dll from a dll?

Leave a Comment