注

Question

考虑以下代码：

#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;
}

它运行定时器以定期频率调用timerCallback（..）。在此示例中，必须每秒调用5000次回调。人们可以玩频率，看到实际（测量）的呼叫频率与所需频率不同。事实上，频率越高，偏差越大。我做了一些不同频率的测量，这里是摘要： https://docs.google.com/spreadsheets/d/1SQtg2slNv-9VPdgS0RD4yKRnyDK1ijKrjVz7BBMSg24/edit?usp=sharing

当所需频率为10000Hz时，系统会错过10％（~1000）的呼叫。当所需频率为100000Hz时，系统会错过40％（~40000）的呼叫。

问题：是否有可能在Linux \ C ++环境中实现更高的准确性？怎么样？我需要它才能在500000Hz的频率下没有明显的偏差

P.S。我的第一个想法是，它是timerCallback（..）方法本身的主体导致延迟。我测量了它。执行时需要不到1微秒的稳定时间。所以它不会影响这个过程。

Answer 1

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

希望这能为您找到答案的方向。

调度程序： http://gumstix.8.x6.nabble.com/High-resolution-periodic-task-on-overo-td4968642.html

优先级： https://linux.die.net/man/3/setpriority

Answer 2

如果你需要每隔2微秒间隔进行一次呼叫，你最好连接到绝对时间位置，而不要考虑每个请求需要的时间....你运行虽然遇到了问题每个时隙所需的处理可能比执行所需的时间要求更高。

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

注

在这种方法中，外部总线可能是一个瓶颈，所以即使你让它工作，也许最好将几台机器与NTP同步（这可以以实际GBit的速度完成到usec级别）链接）并使用并行运行的不同处理器。由于你没有描述过程的任何内容，你必须如此密集地重复，我无法为这个问题提供更多的帮助。

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

2 个答案:

注