value_source.hpp

Go to the documentation of this file.

#pragma once
#include <atomic>
#include <cstdint>

 
#include <array>
#include <cstddef>
#include <type_traits>
 
#include <pulp/runtime/triple_buffer.hpp>
 
namespace pulp::dataplane {
 
class ValueChannelSet;
 
namespace detail {
class ScalarTelemetryState;
class MeterTelemetryState;
class VectorTelemetryState;
class EventTelemetryState;
 
template <typename T> struct PublishedValue {
    T value{};
    std::uint64_t publication = 0;
};
} // namespace detail

struct MeterFrame {
    static constexpr int kMaxChannels = 8;
    std::array<float, kMaxChannels> rms{};
    std::array<float, kMaxChannels> peak{};
    int channels = 0;
};
 
static_assert(std::is_trivially_copyable_v<MeterFrame>);

class PublishCounter {
  public:
    void note_publish() noexcept {
        publish_seq_.fetch_add(1, std::memory_order_relaxed);
    }

    std::uint32_t publish_seq() const noexcept {
        return publish_seq_.load(std::memory_order_relaxed);
    }
 
  private:
    std::atomic<std::uint32_t> publish_seq_{0};
};

class MeterSource : public PublishCounter {
  public:
    ~MeterSource();

    void publish(const MeterFrame& frame);

    MeterFrame read();
 
  private:
    friend class ValueChannelSet;
    runtime::TripleBuffer<detail::PublishedValue<MeterFrame>> buffer_;
    detail::MeterTelemetryState* telemetry_ = nullptr;
    std::uint64_t writer_publication_ = 0;
};

struct VectorFrame {
    static constexpr int kMaxSamples = 4096;
    std::array<float, kMaxSamples> samples{};
    int count = 0;
};
 
static_assert(std::is_trivially_copyable_v<VectorFrame>);

struct ValueEvent {
    std::uint32_t frame_index = 0;
    float value = 0.0f;
};
 
static_assert(std::is_trivially_copyable_v<ValueEvent>);

struct EventFrame {
    static constexpr int kMaxEvents = 1024;
    std::array<ValueEvent, kMaxEvents> events{};
    int count = 0;
    std::uint32_t publication = 0;
};
 
static_assert(std::is_trivially_copyable_v<EventFrame>);

class VectorSource : public PublishCounter {
  public:
    ~VectorSource();

    void publish(const float* samples, int count);

    VectorFrame read();
 
  private:
    friend class ValueChannelSet;
    runtime::TripleBuffer<detail::PublishedValue<VectorFrame>> buffer_;
    detail::VectorTelemetryState* telemetry_ = nullptr;
    std::uint64_t writer_publication_ = 0;
};

class EventSource : public PublishCounter {
  public:
    ~EventSource();

    void publish(const ValueEvent* events, int count);

    EventFrame read();
 
  private:
    friend class ValueChannelSet;
    runtime::TripleBuffer<detail::PublishedValue<EventFrame>> buffer_;
    detail::EventTelemetryState* telemetry_ = nullptr;
    // Single-writer state: only publish() touches this counter.
    std::uint64_t writer_publication_ = 0;
};

class ScalarSource : public PublishCounter {
  public:
    ~ScalarSource();

    void publish(float value);

    float read();
 
  private:
    friend class ValueChannelSet;
    runtime::TripleBuffer<detail::PublishedValue<float>> buffer_;
    detail::ScalarTelemetryState* telemetry_ = nullptr;
    std::uint64_t writer_publication_ = 0;
};
 
} // namespace pulp::dataplane