CODEWITHSUNDEEP
c++c++11
Ilyssis
Ilyssis

Reputation: 4949

Run loop every millisecond with sleep_for

I want to run a loop inside a thread that calculates some data every millisecond. But I am having trouble with the sleep function. It is sleeping much too long.

I created a basic console application in visual studio:

#include <windows.h>
#include <iostream>
#include <chrono>
#include <thread>

using namespace std;
typedef std::chrono::high_resolution_clock Clock;

int _tmain(int argc, _TCHAR* argv[])
{
    int iIdx = 0;
    bool bRun = true;

    auto aTimeStart = Clock::now();

    while (bRun){
        iIdx++;
        if (iIdx >= 500) bRun = false;

        //Sleep(1);
        this_thread::sleep_for(chrono::microseconds(10));
    }

    printf("Duration: %i ms\n", chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - aTimeStart).count());

    cin.get();

    return 0;
}

This prints out: Duration: 5000 ms The same result is printed, when i use Sleep(1);

I would expect the duration to be 500 ms, and not 5000 ms. What am I doing wrong here?

Update:

I was using Visual Studio 2013. Now I have installed Visual Studio 2015, and its fine - prints out: Duration: 500 ms (sometimes its 527 ms).

However, this sleep_for still isn't very accurate, so I will look out for other solutions.

Upvotes: 1

Views: 2764

Answers (4)

JohnA
JohnA

Reputation: 821

This thread is fairly old, but perhaps someone can still use this code.

It's written for C++11 and I've tested it on Ubuntu 15.04. 

class MillisecondPerLoop
  {
  public:
    void do_loop(uint32_t loops)
      {
      int32_t time_to_wait = 0;
      next_clock = ((get_current_clock_ns() / one_ms_in_ns) * one_ms_in_ns);
      for (uint32_t loop = 0; loop < loops; ++loop)
        {
        on_tick();

        // Assume on_tick takes less than 1 ms to run

        // calculate the next tick time and time to wait from now until that time
        time_to_wait = calc_time_to_wait();

        // check if we're already past the 1ms time interval
        if (time_to_wait > 0)
          {
          // wait that many ns
          std::this_thread::sleep_for(std::chrono::nanoseconds(time_to_wait));
          }
        ++m_tick;
      }
    }

 private:
   void on_tick()
     {
     // TEST only: simulate the work done in every tick
     // by waiting a random amount of time
      std::this_thread::sleep_for(std::chrono::microseconds(distribution(generator)));
     }

   uint32_t get_current_clock_ns()
     {
     return std::chrono::duration_cast<std::chrono::nanoseconds>(
     std::chrono::system_clock::now().time_since_epoch()).count();
     }

   int32_t calc_time_to_wait()
     {
     next_clock += one_ms_in_ns;
     return next_clock - get_current_clock_ns();
     }

   static constexpr uint32_t one_ms_in_ns = 1000000L;

   uint32_t m_tick;
   uint32_t next_clock;
 };

A typical run shows a pretty accurate 1ms loop with a 1- 3 microsecond error. Your PC may be more accurate than this if it's a faster CPU.

Here's typical output:

One Second Loops:
        Avg (ns)       ms   err(ms)
   [ 0]   999703   0.9997   0.0003
   [ 1]   999888   0.9999   0.0001
   [ 2]   999781   0.9998   0.0002
   [ 3]   999896   0.9999   0.0001
   [ 4]   999772   0.9998   0.0002
   [ 5]   999759   0.9998   0.0002
   [ 6]   999879   0.9999   0.0001
   [ 7]   999915   0.9999   0.0001
   [ 8]  1000043   1.0000  -0.0000
   [ 9]   999675   0.9997   0.0003
   [10]  1000120   1.0001  -0.0001
   [11]   999606   0.9996   0.0004
   [12]   999714   0.9997   0.0003
   [13]  1000171   1.0002  -0.0002
   [14]   999670   0.9997   0.0003
   [15]   999832   0.9998   0.0002
   [16]   999812   0.9998   0.0002
   [17]   999868   0.9999   0.0001
   [18]  1000096   1.0001  -0.0001
   [19]   999665   0.9997   0.0003
Expected total time: 20.0000ms
Actual total time  : 19.9969ms

I have a more detailed write up here: https://arrizza.org/wiki/index.php/One_Millisecond_Loop

Upvotes: 0

Lightness Races in Orbit
Lightness Races in Orbit

Reputation: 385108

What am I doing wrong here?

Attempting to use sleep for precise timing.

sleep(n) does not pause your thread for precisely n time then immediately continue.

sleep(n) yields control of the thread back to the scheduler, and indicates that you do not want control back until at least n time has passed.

Now, the scheduler already divvies up thread processing time into time slices, and these are typically on the order of 25 milliseconds or so. That's the bare minimum you can expect your sleep to run.

sleep is simply the wrong tool for this job. Never use it for precise scheduling.

Upvotes: 0

Daniel
Daniel

Reputation: 31559

On Windows, try timeBeginPeriod: https://msdn.microsoft.com/en-us/library/windows/desktop/dd757624(v=vs.85).aspx
It increases timer resolution.

Upvotes: 0

Alan Stokes
Alan Stokes

Reputation: 18964

The typical time slice used by popular OSs is much longer than 1ms (say 20ms or so); the sleep sets a minimum for how long you want your thread to be suspended not a maximum. Once your thread becomes runnable it is up to the OS when to next schedule it.

If you need this level of accuracy you either need a real time OS, or set a very high priority on your thread (so it can pre-empt almost anything else), or write your code in the kernel, or use a busy wait.

But do you really need to do the calculation every ms? That sort of timing requirement normally comes from hardware. What goes wrong if you bunch up the calculations a bit later?

Upvotes: 4

Related Questions