test_sanitizerConcurrency.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <memory>
#include <thread>
#include <vector>
 
#include "mocks/mockRawEthernetSocket.h"
#include "profinet/cyclic.h"
#include "profinet/rt.h"
 
using namespace profinet;
using namespace profinet::cyclic;
 
namespace
{
 
constexpr MacAddress kControllerMac{0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
constexpr MacAddress kDeviceMac{0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
constexpr std::uint16_t kInputFrameId = 0xC001;
constexpr std::uint16_t kOutputFrameId = 0xC000;
 
rt::IOCRConfig MakeConfig(std::uint16_t frameId, std::uint16_t type)
{
  rt::IOCRConfig config;
  config.typeIOCR = type;
  config.frameId = frameId;
  config.sendClockFactor = 32U;
  config.reductionRatio = 8U;
  config.watchdogFactor = 3U;
  config.dataLength = 40U;
  config.objects.push_back(rt::IODataObject{
      .slot = 1,
      .subslot = 1,
      .frameOffset = 0,
      .dataLength = 4,
      .offsetIOPS = 4,
      .offsetIOCS = 5});
  return config;
}
 
std::unique_ptr<CyclicController> MakeController()
{
  asio::io_context ioContext;
 
  return std::make_unique<CyclicController>(
      ioContext, "eth0", kControllerMac, kDeviceMac,
      MakeConfig(kInputFrameId, rt::IOCR_TYPE_INPUT),
      MakeConfig(kOutputFrameId, rt::IOCR_TYPE_OUTPUT),
      DEFAULT_MAX_CONSECUTIVE_TIMEOUTS, rt::ETHERTYPE_PROFINET);
}
 
} // namespace
 
TEST(SanitizerConcurrencyTest, ConcurrentStatisticsSnapshotIsRaceFree)
{
  auto tx = std::make_unique<testing::NiceMock<MockRawEthernetSocket>>();
  auto rx = std::make_unique<testing::NiceMock<MockRawEthernetSocket>>();
 
  auto controller = MakeController();
 
  controller->Start(std::move(tx), std::move(rx));
 
  std::atomic<bool> stop{false};
  std::atomic<std::uint64_t> snapshots{0U};
 
  std::thread reader([&]()
  {
    while (!stop.load(std::memory_order_acquire))
    {
      const auto snapshot = controller->StatsSnapshot();
      static_cast<void>(snapshot.framesSent);
      static_cast<void>(snapshot.framesReceived);
      static_cast<void>(snapshot.framesMissed);
      static_cast<void>(snapshot.cycleCount);
      static_cast<void>(snapshot.cycleTimeSumUs);
      static_cast<void>(snapshot.AvgCycleTimeUs());
      snapshots.fetch_add(1U, std::memory_order_relaxed);
    }
  });
 
  std::this_thread::sleep_for(std::chrono::milliseconds(20));
 
  stop.store(true, std::memory_order_release);
  reader.join();
  controller->Stop();
 
  EXPECT_GT(snapshots.load(std::memory_order_relaxed), 0U);
}
 
TEST(SanitizerConcurrencyTest, ConcurrentOutputDataWritersAreRaceFree)
{
  auto controller = MakeController();
 
  constexpr std::size_t kWriterCount = 4U;
  constexpr std::size_t kIterations = 5000U;
  std::atomic<bool> failed{false};
 
  std::vector<std::thread> writers;
  writers.reserve(kWriterCount);
 
  for (std::size_t writerIndex = 0U; writerIndex < kWriterCount; ++writerIndex)
  {
    writers.emplace_back([&, writerIndex]()
    {
      for (std::size_t iteration = 0U; iteration < kIterations; ++iteration)
      {
        try
        {
          const std::size_t length = (iteration % 16U) + 1U;
          const auto value = static_cast<std::uint8_t>(writerIndex + iteration);
          controller->SetOutputData(1, 1, Bytes(length, value));
        }
        catch (...)
        {
          failed.store(true, std::memory_order_release);
          return;
        }
      }
    });
  }
 
  for (auto& writer : writers)
  {
    writer.join();
  }
 
  EXPECT_FALSE(failed.load(std::memory_order_acquire));
}
 
TEST(SanitizerConcurrencyTest, RepeatedStartStopJoinsWorkers)
{
  auto controller = MakeController();
 
  for (std::size_t iteration = 0U; iteration < 50U; ++iteration)
  {
    auto tx = std::make_unique<testing::NiceMock<MockRawEthernetSocket>>();
    auto rx = std::make_unique<testing::NiceMock<MockRawEthernetSocket>>();
 
    controller->Start(std::move(tx), std::move(rx));
    EXPECT_TRUE(controller->IsRunning());
 
    std::this_thread::sleep_for(std::chrono::milliseconds(2));
 
    controller->Stop();
    EXPECT_FALSE(controller->IsRunning());
    EXPECT_EQ(controller->State(), CyclicState::Stopped);
  }
}
 
TEST(SanitizerConcurrencyTest, DestructionAfterWorkerActivityIsClean)
{
  for (std::size_t iteration = 0U; iteration < 25U; ++iteration)
  {
    auto tx = std::make_unique<testing::NiceMock<MockRawEthernetSocket>>();
    auto rx = std::make_unique<testing::NiceMock<MockRawEthernetSocket>>();
 
    auto controller = MakeController();
    controller->Start(std::move(tx), std::move(rx));
    std::this_thread::sleep_for(std::chrono::milliseconds(2));
    controller->Stop();
  }
}