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;
  // Per-output-object staging slots, one per entry in image->outputs (rebuilt and seeded at each
  // re-map). A writer stores its object's latest wire bytes (≤8, packed little-endian into the u64)
  // here lock-free — writers to different objects never contend; the same object is last-writer-
  // wins. The RT loop reads every slot each cycle and composes the output image (one thread
  // composing is what keeps bit-packed objects sharing a byte safe without a lock; NEXTGEN Design
  // B).
  std::vector<std::atomic<uint64_t>> outputSlots;
  static_assert(std::atomic<uint64_t>::is_always_lock_free,
                "output staging slots must be lock-free so the RT path never blocks");
  // 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;
  // Set by the RT thread while it is inside a driver exchange; lets stopExchange() drain an
  // in-flight cycle before a re-map or teardown mutates the IOmap.
  std::atomic<bool> exchanging{false};
  // 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};
 
  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 writePdo(uint16_t slavePosition, uint16_t index, uint8_t subindex,
                std::span<const uint8_t> bytes);
};
 
}  // namespace mm::node