How to guarantee exact thread sleep interval?

Question

Usually if I want to simulate some work or wait exact time interval I use condition_variable::wait_for or at the worst thread::this_thread::sleep_for. But condition_variable documentation states that wait_for or wait_until methods may block longer than was requested.

This function may block for longer than timeout_duration due to scheduling or resource contention delays.

How exact wait intervals can be guaranteed?

UPDATE

Can I reach it without condition_variable?

Answer 1

You cannot do this.

In order to have exact guarantees like this, you need a real time operating system.

C++ does not guarantee you are on a real time operating system.

So it provides the guarantees that a typical, non-RTOS provides.

Note that there are other complications to programming on a RTOS that go far beyond the scope of this question.

In practice, one thing people when they really want fine-grained timing control (say, they are twiddling around with per-frame or per-scanline buffers or the like, or audio buffers, or whatever) do is check if the time is short, and if so spin-wait. If the time is longer, they wait for a bit less than the amount of time they want to wait for, then wake up and spin.

This is also not guaranteed to work, but works well enough for almost all cases.

On a RTOS, the platform may provide primitives like you want. These lie outside the scope of standard C++. No typical desktop OS is an RTOS that I am aware of. If you are programming for a fighter jet's control hardware or similar, you may be programming on an RTOS.

I hope you aren't writing fighter jet control software and asking this question on stack overflow.

Answer 2

If you did hypothetically sleep for precisely some exact duration, and then performed some action in response (such as getting the current time, or printing a message to the screen), then that action might be delayed for some unknown period of time e.g. due to processor load. This is equivalent to the action happening (almost) immediately but the timer taking longer than expected. Even in the best case scenario, where the timer completes at precisely the time you request, and the operating system allows your action to complete without preempting your process, it will take a few clock cycles to perform that action.

So in other words, on a standard operating system, it is impossible or maybe even meaningless for a timer to complete at precisely the time requested.

How can this be overcome? An academic answer is that you can used specialized software and hardware such as a real-time operating system, but this is vastly more complicated to develop software for than regular programming. What you probably really want to know is, in the common case, the delay that that documentation refers to is not substantial i.e. it is commonly less that 1/100th second.

Answer 3

With a brute force loop... for example:

chrono::microseconds sleep_duration{1000};

auto now = chrono::high_resolution_clock::now()

while(true)
{
    auto elapsed = chrono::duration_cast<hrono::microseconds>(chrono::high_resolution_clock::now() - now);
    if (elapsed > sleep_duration)
        break;
}

That's bit ugly but desktop operating system are not real time so you cannot have such precision.

In order to relax the cpu you look the following snippet:

void little_sleep(std::chrono::microseconds us)
{
    auto start = std::chrono::high_resolution_clock::now();
    auto end = start + us;
    do {
        std::this_thread::yield();
    } while (std::chrono::high_resolution_clock::now() < end);
}

Answer 4

That depends on what accuracy you can expect. Generally as others have said regular OS (Linux, Windows) cannot guaranty that.

Why?
Your OS have probably has concept of threads. If so, then there is a scheduler which interrupts threads and switch execution to other threads waiting in the queue. And this can spoil accuracy of timers.

What can I do about it?

1. If you are using embedded system - go for bare metal, i.e. don't use OS or use so called hard real time operating system.
2. If you are using Linux, look for Linux RT Preempt Patch in Google. You have to recompile your kernel to include the path (not so complicated though) and then you can create threads with priority above 50 - which means priority above kernel's thread - which in the end means that you can have a thread that can interrupt scheduler and kernel in general, providing quite good time accuracy. In my case it what three orders of magnitude (from few ms of latency to few us).
3. If you are using Windows, I don't know about such patch, but you can search for for High Precisions timers on Microsoft site. Maybe provided accuracy will be enough for your needs.