How to increase sleep/pause timing accuracy in python?

Question

I ran an experiment to compare sleep/pause timing accuracy in python and C++

Experiment summary:

In a loop of 1000000 iterations, sleep 1 microsecond in each iteration.

Expected duration: 1.000000 second (for 100% accurate program)

In python:

import pause
import datetime

start = time.time()
dt = datetime.datetime.now()
for i in range(1000000):
    dt += datetime.timedelta(microseconds=1)
    pause.until(dt)
end = time.time()
print(end - start)

Expected: 1.000000 sec, Actual (approximate): 2.603796

In C++:

#include <iostream>
#include <chrono>
#include <thread>

using namespace std;

using usec = std::chrono::microseconds;
using datetime = chrono::_V2::steady_clock::time_point;
using clk = chrono::_V2::steady_clock;

int main()
{
    datetime dt;
    usec timedelta = static_cast<usec>(1);

    dt = clk::now();

    const auto start = dt;

    for(int i=0; i < 1000000; ++i) {
        dt += timedelta;
        this_thread::sleep_until(dt);
    }

    const auto end = clk::now();

    chrono::duration<double> elapsed_seconds = end - start;

    cout << elapsed_seconds.count();

    return 0;
}

Expected: 1.000000 sec, Actual (approximate): 1.000040

It is obvious that C++ is much more accurate, but I am developing a project in python and need to increase the accuracy. Any ideas?

P.S It's OK if you suggest another python library/technique as long as it is more accurate :)

Answer 1

The problem is not only that the sleep timer of python is inaccurate, but that each part of the loop requires some time.

Your original code has a run-time of ~1.9528656005859375 on my system.

If I only run this part of your code without any sleep:

for i in range(100000):
   dt += datetime.timedelta(microseconds=1)

Then the required time for that loop is already ~0.45999741554260254.

If I only run

for i in range(1000000):
   pause.milliseconds(0)

Then the run-time of the code is ~0.5583224296569824.

Using always the same date:

dt = datetime.datetime.now()
for i in range(1000000):
    pause.until(dt)

Results in a runtime of ~1.326077938079834

If you do the same with the timestamp:

dt = datetime.datetime.now()
ts = dt.timestamp()
for i in range(1000000):
    pause.until(ts)

Then the run-time changes to ~0.36722803115844727

And if you increment the timestamp with one microsecond:

dt = datetime.datetime.now()
ts = dt.timestamp()
for i in range(1000000):
    ts += 0.000001
    pause.until(ts)

Then you get a runtime of ~0.9536933898925781

That it is smaller then 1 is due to floating point inaccuracies, adding print(ts-dt.timestamp()) after the loop will show ~0.95367431640625, so the pause duration itself is correct, but the ts += 0.000001 is accumulating an error.

You will get the best result if you count the iterations you had and add iterationCount/1000000 to the start time:

dt = datetime.datetime.now()
ts = dt.timestamp()
for i in range(1000000):
    pause.until(ts+i/1000000)

And this would result in ~1.000023365020752

So in my case pause itself would already allow an accuracy with less then 1 microsecond. The problem is actually in the datetime part that is required for both datetime.timedelta and sleep_until.

So if you want to have microseconds accuracy then you need to look for a time library that performs better then datetime.

Answer 2

import pause
import datetime
import time

start = time.time()
dt = datetime.datetime.now()

for i in range(1000000):
    dt += datetime.timedelta(microseconds=1)
    pause.until(1) 
end = time.time()
print(end - start)

OUTPUT:

1.0014092922210693

Answer 3

The pause library says that

The precision should be within 0.001 of a second, however, this will depend on how >precise your system sleep is and other performance factors.

If you multiply 0.001 by 1000000 you will get a large accumulated error.

A couple of questions:

Why do you need to sleep?

What is the minimum required accuracy?

How time consistent are the operations you are calling? If these function calls vary by more than 0.001 then the accumulated error will be more due to the operations you are performing than can be attributed to the pauses/sleeps.

Answer 4

Sleeping a thread is inherently non-deterministic - you cannot talk about 'precision' really for thread sleeep in general - perhaps only in the context of a particular system and platform - there are just too many factors that can possibly play a role for example how many cpu cores, etc..

To illustrate the point, a thought experiment:

Suppose you made many threads (at least 1000) and scheduled them to run at the same exact time. What 'precision' would you then expect ?