Refactor: Split noctx code into more files

Author: Sakoram

.gitignore

@@ -70,7 +70,6 @@ tests/validation/logs
 html/
 test.*
 build/
-core*
 out*
 assets/
 *.pkg

tests/integration_tests/meson.build

@@ -8,6 +8,7 @@ sources = files('tests.cpp', 'st_test.cpp', 'st20_test.cpp', 'st22_test.cpp',
 
 subdir('noctx')
 sources += noctx_sources
+test_inc = include_directories('.', 'noctx')
 
 ufd_sources = files('ufd_test.cpp', 'ufd_loop_test.cpp', 'test_util.cpp')
 

tests/integration_tests/noctx/core/constants.hpp

@@ -0,0 +1,10 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+#pragma once
+
+#ifndef SESSION_SKIP_PORT
+#define SESSION_SKIP_PORT -1
+#endif
+
+#ifndef VIDEO_CLOCK_HZ
+#define VIDEO_CLOCK_HZ 90000
+#endif

tests/integration_tests/noctx/core/handler_base.cpp

@@ -0,0 +1,74 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+
+#include "handler_base.hpp"
+
+#include <cstdio>
+#include <stdexcept>
+
+Handlers::Handlers(st_tests_context* ctx, FrameTestStrategy* frameTestStrategy)
+    : ctx(ctx), frameTestStrategy(frameTestStrategy) {
+}
+
+Handlers::~Handlers() {
+  session.stop();
+}
+
+void Handlers::startSession(
+    std::vector<std::function<void(std::atomic<bool>&)>> threadFunctions) {
+  for (auto& func : threadFunctions) {
+    session.addThread(func);
+  }
+}
+
+void Handlers::stopSession() {
+  session.stop();
+}
+
+void Handlers::setSessionPortsTx(struct st_tx_port* port, int txPortIdx,
+                                 int txPortRedundantIdx) {
+  if (!ctx) {
+    throw std::runtime_error("setSessionPortsTx no ctx (ctx is null)");
+  } else if (txPortIdx >= (int)ctx->para.num_ports) {
+    throw std::runtime_error("setSessionPortsTx txPortIdx out of range");
+  } else if (txPortRedundantIdx >= (int)ctx->para.num_ports) {
+    throw std::runtime_error("setSessionPortsTx txPortRedundantIdx out of range");
+  }
+
+  if (txPortIdx >= 0) {
+    snprintf(port->port[MTL_SESSION_PORT_P], MTL_PORT_MAX_LEN, "%s",
+             ctx->para.port[txPortIdx]);
+    int num_ports = 1;
+
+    if (txPortRedundantIdx >= 0) {
+      snprintf(port->port[MTL_SESSION_PORT_R], MTL_PORT_MAX_LEN, "%s",
+               ctx->para.port[txPortRedundantIdx]);
+      num_ports = 2;
+    }
+
+    port->num_port = num_ports;
+  }
+}
+
+void Handlers::setSessionPortsRx(struct st_rx_port* port, int rxPortIdx,
+                                 int rxPortRedundantIdx) {
+  if (!ctx) {
+    throw std::runtime_error("setSessionPortsRx no ctx (ctx is null)");
+  } else if (rxPortIdx >= (int)ctx->para.num_ports) {
+    throw std::runtime_error("setSessionPortsRx rxPortIdx out of range");
+  } else if (rxPortRedundantIdx >= (int)ctx->para.num_ports) {
+    throw std::runtime_error("setSessionPortsRx rxPortRedundantIdx out of range");
+  }
+
+  if (rxPortIdx >= 0) {
+    snprintf(port->port[MTL_SESSION_PORT_P], MTL_PORT_MAX_LEN, "%s",
+             ctx->para.port[rxPortIdx]);
+    int num_ports = 1;
+
+    if (rxPortRedundantIdx >= 0) {
+      snprintf(port->port[MTL_SESSION_PORT_R], MTL_PORT_MAX_LEN, "%s",
+               ctx->para.port[rxPortRedundantIdx]);
+      num_ports = 2;
+    }
+    port->num_port = num_ports;
+  }
+}

tests/integration_tests/noctx/core/handler_base.hpp

@@ -0,0 +1,28 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+#pragma once
+
+#include <atomic>
+#include <functional>
+#include <vector>
+
+#include "session.hpp"
+#include "strategy.hpp"
+#include "tests.hpp"
+
+class Handlers {
+ public:
+  explicit Handlers(st_tests_context* ctx,
+                    FrameTestStrategy* frameTestStrategy = nullptr);
+  virtual ~Handlers();
+
+  void startSession(
+      std::vector<std::function<void(std::atomic<bool>&)>> threadFunctions = {});
+  void stopSession();
+
+  void setSessionPortsRx(struct st_rx_port* port, int rxPortIdx, int rxPortRedundantIdx);
+  void setSessionPortsTx(struct st_tx_port* port, int txPortIdx, int txPortRedundantIdx);
+
+  Session session;
+  st_tests_context* ctx;
+  FrameTestStrategy* frameTestStrategy;
+};

tests/integration_tests/noctx/core/session.cpp

@@ -0,0 +1,43 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+
+#include "session.hpp"
+
+void Session::addThread(std::function<void(std::atomic<bool>&)> func) {
+  if (!func) {
+    return;
+  }
+
+  if (threads_.empty()) {
+    stopFlag_.store(false);
+  }
+
+  threads_.emplace_back(func, std::ref(stopFlag_));
+}
+
+bool Session::isRunning() const {
+  if (threads_.empty()) {
+    return false;
+  }
+
+  for (const auto& thread : threads_) {
+    if (!thread.joinable()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void Session::stop() {
+  stopFlag_ = true;
+  for (auto& thread : threads_) {
+    if (thread.joinable()) {
+      thread.join();
+    }
+  }
+  threads_.clear();
+}
+
+Session::~Session() {
+  stop();
+}

tests/integration_tests/noctx/core/session.hpp

@@ -0,0 +1,22 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+#pragma once
+
+#include <atomic>
+#include <functional>
+#include <thread>
+#include <vector>
+
+/**
+ * @brief Helper that owns the background threads used by TX/RX handlers.
+ */
+class Session {
+ public:
+  void addThread(std::function<void(std::atomic<bool>&)> func);
+  bool isRunning() const;
+  void stop();
+  ~Session();
+
+ private:
+  std::vector<std::thread> threads_;
+  std::atomic<bool> stopFlag_{false};
+};

tests/integration_tests/noctx/core/strategy.cpp

@@ -0,0 +1,42 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+
+#include "strategy.hpp"
+
+#include <utility>
+
+void StrategySharedState::setPacingParameters(double tr_offset_ns, double trs_ns,
+                                              uint32_t vrx_pkts) {
+  std::lock_guard<std::mutex> lock(pacing_mutex_);
+  pacing_.tr_offset_ns = tr_offset_ns;
+  pacing_.trs_ns = trs_ns;
+  pacing_.vrx_pkts = vrx_pkts;
+  pacing_.has_value = true;
+}
+
+StrategySharedState::PacingParameters StrategySharedState::getPacingParameters() const {
+  std::lock_guard<std::mutex> lock(pacing_mutex_);
+  return pacing_;
+}
+
+FrameTestStrategy::FrameTestStrategy(Handlers* parent, bool enable_tx_modifier,
+                                     bool enable_rx_modifier)
+    : parent(parent),
+      idx_tx(0),
+      idx_rx(0),
+      expect_fps(0.0),
+      enable_tx_modifier(enable_tx_modifier),
+      enable_rx_modifier(enable_rx_modifier),
+      shared_state_(nullptr) {
+}
+
+FrameTestStrategy::~FrameTestStrategy() {
+  parent = nullptr;
+}
+
+void FrameTestStrategy::setSharedState(std::shared_ptr<StrategySharedState> state) {
+  shared_state_ = std::move(state);
+}
+
+std::shared_ptr<StrategySharedState> FrameTestStrategy::sharedState() const {
+  return shared_state_;
+}

tests/integration_tests/noctx/core/strategy.hpp

@@ -0,0 +1,51 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <mutex>
+
+class Handlers;
+
+class StrategySharedState {
+ public:
+  struct PacingParameters {
+    double tr_offset_ns = 0.0;
+    double trs_ns = 0.0;
+    uint32_t vrx_pkts = 0;
+    bool has_value = false;
+  };
+
+  void setPacingParameters(double tr_offset_ns, double trs_ns, uint32_t vrx_pkts);
+  PacingParameters getPacingParameters() const;
+
+ private:
+  mutable std::mutex pacing_mutex_;
+  PacingParameters pacing_;
+};
+
+class FrameTestStrategy {
+ public:
+  FrameTestStrategy(Handlers* parent = nullptr, bool enable_tx_modifier = false,
+                    bool enable_rx_modifier = false);
+  virtual ~FrameTestStrategy();
+
+  void setSharedState(std::shared_ptr<StrategySharedState> state);
+  std::shared_ptr<StrategySharedState> sharedState() const;
+
+  virtual void txTestFrameModifier(void* frame, size_t frame_size) {
+  }
+  virtual void rxTestFrameModifier(void* frame, size_t frame_size) {
+  }
+
+  Handlers* parent;
+  uint32_t idx_tx;
+  uint32_t idx_rx;
+  double expect_fps;
+  bool enable_tx_modifier;
+  bool enable_rx_modifier;
+
+ private:
+  std::shared_ptr<StrategySharedState> shared_state_;
+};