C++ C++；如何在Linux中使计时器精确

考虑以下代码：

#include <iostream>
#include <vector>
#include <functional>
#include <map>
#include <atomic>
#include <memory>
#include <chrono>
#include <thread>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/asio/high_resolution_timer.hpp>

static const uint32_t FREQUENCY = 5000; // Hz
static const uint32_t MKSEC_IN_SEC = 1000000;

std::chrono::microseconds timeout(MKSEC_IN_SEC / FREQUENCY);
boost::asio::io_service ioservice;
boost::asio::high_resolution_timer timer(ioservice);

static std::chrono::system_clock::time_point lastCallTime = std::chrono::high_resolution_clock::now();
static uint64_t deviationSum = 0;
static uint64_t deviationMin = 100000000;
static uint64_t deviationMax = 0;
static uint32_t counter = 0;

void timerCallback(const boost::system::error_code &err) {
  auto actualTimeout = std::chrono::high_resolution_clock::now() - lastCallTime;
  std::chrono::microseconds actualTimeoutMkSec = std::chrono::duration_cast<std::chrono::microseconds>(actualTimeout);
  long timeoutDeviation = actualTimeoutMkSec.count() - timeout.count();
  deviationSum += abs(timeoutDeviation);
  if(abs(timeoutDeviation) > deviationMax) {
    deviationMax = abs(timeoutDeviation);
  } else if(abs(timeoutDeviation) < deviationMin) {
    deviationMin = abs(timeoutDeviation);
  }

  ++counter;
  //std::cout << "Actual timeout: " << actualTimeoutMkSec.count() << "\t\tDeviation: " << timeoutDeviation << "\t\tCounter: " << counter << std::endl;

  timer.expires_from_now(timeout);
  timer.async_wait(timerCallback);
  lastCallTime = std::chrono::high_resolution_clock::now();
}

using namespace std::chrono_literals;

int main() {
  std::cout << "Frequency: " << FREQUENCY << " Hz" << std::endl;
  std::cout << "Callback should be called each: " << timeout.count() << " mkSec" << std::endl;
  std::cout << std::endl;

  ioservice.reset();
  timer.expires_from_now(timeout);
  timer.async_wait(timerCallback);
  lastCallTime = std::chrono::high_resolution_clock::now();
  auto thread = new std::thread([&] { ioservice.run(); });
  std::this_thread::sleep_for(1s);

  std::cout << std::endl << "Messages posted: " << counter << std::endl;
  std::cout << "Frequency deviation: " << FREQUENCY - counter << std::endl;
  std::cout << "Min timeout deviation: " << deviationMin << std::endl;
  std::cout << "Max timeout deviation: " << deviationMax << std::endl;
  std::cout << "Avg timeout deviation: " << deviationSum / counter << std::endl;

  return 0;
}

#包括
#包括
#包括
#包括
#包括

当所需频率为10000Hz时，系统将错过10%（约1000次）的呼叫。
当所需频率为100000Hz时，系统将错过40%（约40000次）的呼叫

问题：在Linux\C++环境中是否有可能实现更好的准确性？如何？我需要它在频率为500000Hz的情况下工作而不会产生明显偏差

另外，我的第一个想法是timerCallback（..）方法本身会导致延迟。我量了量。它需要不到1微秒的时间来执行。因此它不会影响进程。
我自己在这个问题上没有经验，但我猜（正如参考文献所解释的）操作系统的调度程序会以某种方式干扰您的回调。
所以，您可以尝试使用实时调度程序，并尝试将任务的优先级更改为更高的优先级

希望这能给你一个找到答案的方向

调度程序：

优先权：
我自己在这个问题上没有经验，但我猜（正如参考资料所解释的）操作系统的调度程序会以某种方式干扰您的回调。
所以，您可以尝试使用实时调度程序，并尝试将任务的优先级更改为更高的优先级

希望这能给你一个找到答案的方向

调度程序：

优先权：
如果你需要每两微秒间隔一次调用，你最好附加到绝对时间位置，不要考虑每个请求所需的时间。但是，您会遇到这样的问题：每个时隙所需的处理可能比执行所需的时间对cpu的要求更高

如果您有一个多核cpu，我会在每个核心之间划分时间段（在多线程方法中），使每个核心的时间段更长，因此假设您的需求在一个四核cpu中，那么您可以允许每个线程每8usec执行1个cal，这可能更便宜。在这种情况下，您使用绝对计时器（一个绝对计时器是指等待直到挂钟滴答一个特定的绝对时间，而不是从您调用它的时间开始的延迟），并将它们偏移等于2usec delay的线程数的量，在这种情况下（4个内核），您将在时间T启动线程#1，在时间T+2usec启动线程#2，线程#3在时间T+4usec。。。和线程#N在时间T+2*（N-1）usec处。然后，每个线程将在oldT+2usec时重新启动自身，而不是执行某种
nsleep（3）
调用。这不会累积延迟调用的处理时间，因为这很可能是您正在经历的。pthread库计时器都是绝对时间计时器，因此您可以使用它们。我认为这是你能够达到这样一个硬规格的唯一方法。（假设你在安卓环境中，准备看看电池是如何受到影响的）

注
在这种方法中，外部总线可能是一个瓶颈，因此，即使您让它工作起来，也最好将多台机器与NTP同步（这可以以实际GBit链路的速度达到usec级别），并使用并行运行的不同处理器。由于你没有描述任何过程，你必须重复如此密集，我不能提供更多的帮助问题。
 < P>如果你需要每两微秒间隔一次调用，你最好附加到绝对的时间位置，不要考虑每个请求所需要的时间。但是，您会遇到这样的问题：每个时隙所需的处理可能比执行所需的时间对cpu的要求更高

如果您有一个多核cpu，我会在每个核心之间划分时间段（在多线程方法中），使每个核心的时间段更长，因此假设您的需求在一个四核cpu中，那么您可以允许每个线程每8usec执行1个cal，这可能更便宜。在这种情况下，您使用绝对计时器（一个绝对计时器是指等待直到挂钟滴答一个特定的绝对时间，而不是从您调用它的时间开始的延迟），并将它们偏移等于2usec delay的线程数的量，在这种情况下（4个内核），您将在时间T启动线程#1，在时间T+2usec启动线程#2，线程#3在时间T+4usec。。。和线程#N在时间T+2*（N-1）usec处。然后，每个线程将在oldT+2usec时重新启动自身，而不是执行某种
nsleep（3）
调用。这不会累积延迟调用的处理时间，因为这很可能是您正在经历的。pthread库计时器都是绝对时间计时器，因此您可以使用它们。我认为这是你能够达到这样一个硬规格的唯一方法。（假设你在安卓环境中，准备看看电池是如何受到影响的）

注
在这种方法中，外部总线可能是一个瓶颈，因此，即使您让它工作起来，也最好将多台机器与NTP同步（这可以以实际GBit链路的速度达到usec级别），并使用并行运行的不同处理器。由于您没有详细描述您必须重复的任何过程，因此我无法提供更多帮助。
不要使用
std:：chrono:：high_-resolution_-clock
或
std:：chrono:：system_-clock
使用
std:：chrono:：stable_-clock
。试一下。偏差甚至比高分辨率时钟的精度更高。高分辨率时钟只是稳定时钟的一种类型。退房有关您应该在高分辨率上使用稳定时钟的原因的更多信息，以及有关时钟的更多好信息。如果您希望每秒被调用特定次数，为什么要这样做：
timer.expires\u from\u now（超时）？这意味着，如果一个呼叫延迟了一微秒，那么下一个呼叫将延迟一微秒。如果你这样做，那是错误的