Method run

app/src/Benchmark/HotpathBenchmark.cpp:563–661

* @brief Drives FrameReader -> FrameBuilder -> consumers end-to-end and measures parsed frames/sec. */

 * @brief Drives FrameReader -> FrameBuilder -> consumers end-to-end and measures parsed frames/sec.
 */
HotpathBenchmark::Result HotpathBenchmark::run(quint64 targetFrames,
                                               double minFps,
                                               double minSeconds,
                                               int language,
                                               bool withExporters,
                                               bool withStrings,
                                               bool withDashboard,
                                               bool dashboardIngest)
{
  Q_ASSERT(targetFrames > 0);
  Q_ASSERT(minFps > 0.0);
  Q_ASSERT(minSeconds >= 0.0);

  constexpr int kChannels       = 8;
  constexpr int kFramesPerChunk = 1000;
  const bool activateDashboard  = withDashboard && dashboardIngest;

  const int channels = withDashboard ? kDashboardChannels : kChannels;
  setupProject(language, channels, withStrings, withDashboard);
  if (withExporters)
    enableConsumers();

  if (activateDashboard)
    setActive(true);

  const int stringColumns = withStrings ? kStringChannels : 0;
  const QByteArray chunk  = buildChunk(kFramesPerChunk, channels, stringColumns);

  IO::FrameReader reader;
  reader.setOperationMode(SerialStudio::QuickPlot);
  reader.setFinishSequences({QByteArrayLiteral("\n")});

  auto& builder = DataModel::FrameBuilder::instance();
  builder.setParseBudgetEnabled(false);

  auto& queue = reader.queue();
  IO::CapturedDataPtr drained;

  if (activateDashboard) {
    reader.processData(IO::makeCapturedData(chunk));

    // code-verify off
    while (queue.try_dequeue(drained))
      builder.hotpathRxFrame(drained);
    // code-verify on

    activateDashboardWidgets();
  }

  builder.resetFrameCounters();

  using Clock             = std::chrono::steady_clock;
  const quint64 maxFrames = targetFrames + static_cast<quint64>(minSeconds * 1.0e9);
  const quint64 maxChunks = maxFrames / kFramesPerChunk + 1;

  quint64 fed        = 0;
  double seconds     = 0.0;
  double spentSpin   = 0.0;