condition_variable::wait_until passes through unexpectedly g++ (9.4.0)

Question

I am trying to understand the behaviour of condition_variable::wait_until. I have two pieces of code which I expect will wait one second and then exit. However, when I execute the programs (compiled with g++ 9.4.0, libc6 2.3.2) the first does not wait at all, whereas the second example does.

(see Update below for how to get correct behaviour in both examples)

Here's the first example which does not wait (unlike what I would expect) when executed:

// foo_passes_thru.cpp
// I compiled with `g++ foo_passes_thru.cpp`
#include <chrono>
#include <mutex>
#include <condition_variable>

std::condition_variable cv;
std::mutex m;

int main(int argc, char * argv[]) {

    using namespace std::chrono_literals;
    
    std::unique_lock<std::mutex> lk(m);
    const auto now = std::chrono::high_resolution_clock::now();
    cv.wait_until(lk, now + 1000ms);

    return 0;

}

And the second example, which, when executed, does wait as expected:

// foo_waits_1sec.cpp
// I compiled with `g++ foo_waits_1sec.cpp -lpthread`
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <thread>

std::condition_variable cv;
std::mutex m;

int main(int argc, char * argv[]) {

    using namespace std::chrono_literals;

    std::thread causes_wait([]{});
    // don't even need the thread to run
    causes_wait.join();

    std::unique_lock<std::mutex> lk(m);
    const auto now = std::chrono::high_resolution_clock::now();
    cv.wait_until(lk, now + 1000ms);

    return 0;

}

• There does not appear to be a difference in the compiled wait_until.
• In both programs, there is ultimately a call to pthread_cond_timedwait.

I am not sure if this is a case of unspecified behaviour or there is something incorrect in g++/STL/pthread. The documentation for pthread_cond_timedwait didn't suggest to me that there should be differences in behaviour.

Update

Upon posting, a related question came up that I hadn't yet seen. The behaviour that I expect is restored for the first example if I add the -pthread compiler option. This option should be used to build both.

Answer 1

wait_until is allowed to wake up spuriously. There is no guarantee that it will wait until the specified time. You need to call wait_until in a loop, check the return value to determine whether a timeout occurred and you need some condition to check in order to decide whether the non-timeout wakeup was spurious. Alternatively you can use the second overload of wait_until that takes the condition as a predicate and implements the loop.

Without the -pthread option the program is single-threaded and a corresponding implementation is probably being used. In that implementation there can never be a non-spurious wakeup, so I think it is not surprising that it would be implemented to return immediately, although I have not checked the sources (of glibc or whichever libc implementation you use).