準確的連續計時器回調

Question

我有一個應用程序，我希望每x毫秒顯示一個幀。

以前我做的是這樣的：

class SomeClass 
{ 
    boost::thread thread_; 
    boost::timer timer_; 
public: 
    SomeClass() : thread_([=]{Display();}) 
    { 
    } 

    void Display 
    {  
     double wait = 1.0/fps*1000.0;  
     while(isRunning_) 
     { 
      double elapsed = timer.elapsed()*1000.0; 
      if(elapsed < wait) 
        boost::this_thread::sleep(boost::posix_time::milliseconds(static_cast<unsigned int>(wait - elapsed))); 
      timer.restart(); 

      // ... Get Frame. This can block while no frames are being rendered. 

      // ... Display Frame. 
     } 
    } 
} 

不過，我不認爲解決方案有很好的精度。我可能錯了？

我希望能用boost :: asio :: deadline_timer代替，但我不確定如何使用它。

這是我試過的，這似乎沒有等待。它似乎只是儘可能快地渲染幀。

class SomeClass 
    { 
     boost::thread thread_; 
     boost::asio::io_service io_; 
     boost::asio::deadline_timer timer_; 

    public: 
     SomeClass() : timer_(io_, 1.0/fps*1000.0) 
     { 
      timer_.async_wait([=]{Display();}); 
      thread_ = boost::thread([=]{io_.run();}) 
     } 

     void Display 
     {  
       double wait = 1.0/fps*1000.0;  
       while(isRunning_) 
       { 
        timer_.expires_from_now(boost::posix_time::milliseconds(wait_)); // Could this overflow? 

        // ... Get Frame. This can block while no frames are being rendered. 

        // ... Display Frame. 

        timer_.async_wait([=]{Display();}); 
       } 
     } 
    } 

我在做什麼錯？如果我得到這個解決方案的工作會比第一個更好嗎？

Answer 1

請記住，幀的顯示精度受顯示器的刷新率限制（典型值爲60 Hz顯示器爲17 ms，75 Hz顯示器爲13 ms）。如果你沒有同步到顯示刷新，那麼你有一個不確定的延遲0-17毫秒，以添加到你使用的任何計時方法，因此精度並不需要比10毫秒好得多（甚至1毫秒可能是矯枉過正）。

Answer 2

下面是使用boost::asio::deadline_timer一個相當簡單的例子，希望這有助於

#include <boost/asio.hpp> 
#include <boost/bind.hpp> 
#include <boost/enable_shared_from_this.hpp> 

#include <iostream> 

class Timer : public boost::enable_shared_from_this<Timer> 
{ 
public: 
    Timer(
      boost::asio::io_service& io_service 
     ) : 
     _io_service(io_service), 
     _timer(io_service) 
    { 

    } 

    void start() { 
     _timer.expires_from_now(
       boost::posix_time::seconds(0) 
       ); 
     _timer.async_wait(
       boost::bind(
        &Timer::handler, 
        shared_from_this(), 
        boost::asio::placeholders::error 
        ) 
       ); 
    } 

private: 
    void handler(
      const boost::system::error_code& error 
      ) 
    { 
     if (error) { 
      std::cerr << error.message() << std::endl; 
      return; 
     } 

     std::cout << "handler" << std::endl; 
     _timer.expires_from_now(
       boost::posix_time::seconds(1) 
       ); 
     _timer.async_wait(
       boost::bind(
        &Timer::handler, 
        shared_from_this(), 
        boost::asio::placeholders::error 
        ) 
       ); 
    } 

private: 
    boost::asio::io_service& _io_service; 
    boost::asio::deadline_timer _timer; 
}; 

int 
main() 
{ 
    boost::asio::io_service io_service; 
    boost::shared_ptr<Timer> timer(
      new Timer(io_service) 
      ); 
    timer->start(); 
    io_service.run(); 
}