value_channel_telemetry.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <span>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
#include <pulp/dataplane/value_source.hpp>
 
namespace pulp::dataplane {

enum class ValueChannelShape {
    scalar, 
    meter,  
    vector, 
    events, 
};

struct ValueChannelInfo {
    std::string name; 
    std::string unit; 
    ValueChannelShape shape = ValueChannelShape::scalar;
    float neutral = 0.0f;
};
 
using ValueChannelContinuousPayload = std::variant<float, MeterFrame, VectorFrame>;

struct ValueChannelTelemetrySnapshot {
    ValueChannelShape shape = ValueChannelShape::scalar;
    ValueChannelContinuousPayload payload = 0.0f;
    std::uint64_t source_publication = 0;
    std::uint64_t ui_snapshot_sequence = 0;
    std::int64_t ui_snapshot_time_ns = 0;
    bool available = false;
};

struct ValueChannelTelemetryEventBatch {
    EventFrame frame;
    std::uint64_t source_publication = 0;
};

struct ValueChannelTelemetryEventStats {
    std::size_t size_approx = 0;
    std::size_t capacity = 0;
    std::uint64_t overflow_count = 0;
};

struct ValueChannelTelemetryDescriptor {
    std::size_t index = 0;
    ValueChannelInfo info;
    bool has_source_timestamp = false;
    bool has_ui_snapshot_timestamp = false;
};
 
namespace detail {
class ValueChannelTelemetryControl;
class ValueChannelTelemetryState;
class ScalarTelemetryState;
class MeterTelemetryState;
class VectorTelemetryState;
class EventTelemetryState;
} // namespace detail

class ValueChannelTelemetryAttachment {
  public:
    ValueChannelTelemetryAttachment();
    ~ValueChannelTelemetryAttachment();
    ValueChannelTelemetryAttachment(ValueChannelTelemetryAttachment&&) noexcept;
    ValueChannelTelemetryAttachment& operator=(ValueChannelTelemetryAttachment&&) noexcept;
    ValueChannelTelemetryAttachment(const ValueChannelTelemetryAttachment&) = delete;
    ValueChannelTelemetryAttachment& operator=(const ValueChannelTelemetryAttachment&) = delete;
 
    bool valid() const noexcept;
    std::span<const ValueChannelTelemetryDescriptor> channels() const noexcept;

    bool read_continuous(std::size_t index, ValueChannelTelemetrySnapshot& snapshot) noexcept;

    bool try_pop_events(std::size_t index, ValueChannelTelemetryEventBatch& batch) noexcept;
    ValueChannelTelemetryEventStats event_stats(std::size_t index) const noexcept;
    bool source_alive(std::size_t index) const noexcept;
 
  private:
    friend class ValueChannelSet;
    struct Impl;
    ValueChannelTelemetryAttachment(
        std::shared_ptr<detail::ValueChannelTelemetryControl> control,
        std::vector<std::shared_ptr<detail::ValueChannelTelemetryState>> states,
        std::vector<ValueChannelInfo> infos);
    std::unique_ptr<Impl> impl_;
};
 
namespace detail {
 
std::shared_ptr<ValueChannelTelemetryControl> make_value_channel_telemetry_control();
std::uint64_t
value_channel_telemetry_control_identity(const ValueChannelTelemetryControl*) noexcept;
void value_channel_telemetry_index_add(ValueChannelTelemetryControl*, std::string_view name,
                                       ValueChannelShape shape, std::size_t index);
std::ptrdiff_t value_channel_telemetry_index_lookup(const ValueChannelTelemetryControl*,
                                                    std::string_view name,
                                                    ValueChannelShape shape) noexcept;
std::shared_ptr<ValueChannelTelemetryState> make_scalar_telemetry_state();
std::shared_ptr<ValueChannelTelemetryState> make_meter_telemetry_state();
std::shared_ptr<ValueChannelTelemetryState> make_vector_telemetry_state();
std::shared_ptr<ValueChannelTelemetryState> make_event_telemetry_state();
 
ScalarTelemetryState* scalar_telemetry_writer(ValueChannelTelemetryState*) noexcept;
MeterTelemetryState* meter_telemetry_writer(ValueChannelTelemetryState*) noexcept;
VectorTelemetryState* vector_telemetry_writer(ValueChannelTelemetryState*) noexcept;
EventTelemetryState* event_telemetry_writer(ValueChannelTelemetryState*) noexcept;
 
void record_scalar_snapshot(ScalarTelemetryState*, float, std::uint64_t) noexcept;
void record_meter_snapshot(MeterTelemetryState*, const MeterFrame&, std::uint64_t) noexcept;
void record_vector_snapshot(VectorTelemetryState*, const VectorFrame&, std::uint64_t) noexcept;
void push_event_telemetry(EventTelemetryState*, const EventFrame&, std::uint64_t) noexcept;
void mark_scalar_source_dead(ScalarTelemetryState*) noexcept;
void mark_meter_source_dead(MeterTelemetryState*) noexcept;
void mark_vector_source_dead(VectorTelemetryState*) noexcept;
void mark_event_source_dead(EventTelemetryState*) noexcept;
 
} // namespace detail
 
} // namespace pulp::dataplane