process_data.h

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <cstdint>
#include <memory>
#include <optional>
#include <span>
#include <vector>
 
#include "node/process_data_ring.h"
#include "node/process_image.h"
 
namespace mm::node {
 
struct ProcessData {
  // The currently published image layout, or nullptr when no image is published (exchange is then
  // a no-op). Loaded lock-free by readers; published with release ordering by the control plane.
  std::atomic<const ProcessImage*> image{nullptr};
  // Every image ever published since the last reset(), retained so a lock-free reader can never
  // dereference a freed image after a re-map republishes a new one.
  std::vector<std::shared_ptr<const ProcessImage>> generations;
  // The lossless flight-data recorder: the RT loop appends one record per cycle (raw input + output
  // IOmap, timestamp, working counter), the source for both the live monitoring stream and point
  // reads of the freshest value (head()-1). Allocated at configureProcessData (sizes known then),
  // re-allocated on a layout-changing re-map, retained across teardown, freed by reset()/scan().
  ProcessDataRing ring;
  // RT-thread scratch for the exchange (touched only on the RT thread).
  ProcessBuffer outScratch;
  ProcessBuffer inScratch;
  // How deep the RT thread currently is inside work that reads the device set or the IOmap; lets
  // stopExchange() drain an in-flight cycle before a re-map or teardown mutates either.
  //
  // A depth counter rather than a flag because it is raised at two nesting levels. GameLoop takes a
  // DeviceManager::CycleGuard around the whole task list, because a task resolves devices and
  // parameters of its own and must not run while the device set is being replaced. Inside that,
  // exchangeProcessData raises it again around the exchange, so it stays self-contained for a
  // caller that invokes it directly. Only the RT thread raises it, so the count is small and
  // bounded by nesting.
  std::atomic<int> inCycle{0};
  // Working-counter health. lastWkc is written by the RT thread each cycle; expectedWkc is
  // recomputed by the control plane from current device states. healthy = last >= expected.
  std::atomic<int> lastWkc{0};
  std::atomic<int> expectedWkc{0};
  // Cumulative record of the cycles the bus did not fully answer, written by the RT thread and
  // cleared only by DeviceManager::reset (they run for the life of one bus session).
  //
  // Deliberately not per image: a re-map happens whenever anyone brings a device into or out of
  // SAFE-OP/OP, so clearing per generation erased the history at the moment someone was chasing
  // a fault, and left the figure describing a window nobody chose.
  //
  // A boolean sampled off the RT path cannot see a fault that arrived and cleared between two
  // samples, and nothing in this process samples continuously — so a count, plus the epoch
  // nanoseconds of the first and last bad cycle, is what survives to be read afterwards. The
  // timestamps are the point: they are what lets a process-data fault be lined up against whatever
  // else the log shows at that moment, which a bare count cannot answer.
  std::atomic<uint64_t> shortWkcCycles{0};
  std::atomic<uint64_t> firstShortWkcNs{0};
  std::atomic<uint64_t> lastShortWkcNs{0};
 
  struct PauseResult {
    const ProcessImage* previous = nullptr;
    bool drained = true;
  };
  PauseResult pauseCycle();
 
  void resumeCycle(const ProcessImage* previous);
 
  bool healthy() const {
    return image.load(std::memory_order_acquire) != nullptr &&
           lastWkc.load(std::memory_order_relaxed) >= expectedWkc.load(std::memory_order_relaxed);
  }
 
  std::optional<std::vector<uint8_t>> readPdo(uint16_t slavePosition, uint16_t index,
                                              uint8_t subindex) const;
 
  bool isOutputMapped(uint16_t slavePosition, uint16_t index, uint8_t subindex) const;
};
 
}  // namespace mm::node