Reference

Common definitions

group Common defintions

Typedefs

using RawDelimSizeType = uint32_t

Enums

enum class DataPrintMode : uint8_t

Values:

enumerator print_speed

enumerator print_header

enumerator print_raw

enumerator print_all

Variables

auto BYTE_BIT_LENGTH = 8

auto DEFAULT_SRS_IP = std::string_view{"10.0.0.2"}

auto DEFAULT_TIMEOUT_SECONDS = 2

auto WRITE_COMMAND_BITS = uint8_t{0xaa}

auto DEFAULT_TYPE_BITS = uint8_t{0xaa}

auto DEFAULT_CHANNEL_ADDRE = uint16_t{0xff}

auto COMMAND_LENGTH_BITS = uint16_t{0xffff}

auto ZERO_UINT16_PADDING = uint16_t{}

auto SMALL_READ_MSG_BUFFER_SIZE = 100

auto LARGE_READ_MSG_BUFFER_SIZE = 10000

size of the data array for reading a UDP package

auto DEFAULT_CMD_LENGTH = uint16_t{0xffff}

auto CMD_TYPE = uint8_t{0xaa}

auto WRITE_CMD = uint8_t{0xaa}

auto READ_CMD = uint8_t{0xbb}

auto I2C_ADDRESS = uint16_t{0x0042}

auto NULL_ADDRESS = uint16_t{0x000f}

auto INIT_COUNT_VALUE = uint32_t{0x80000000}

auto DEFAULT_STATUS_WAITING_TIME_SECONDS = std::chrono::seconds{5}

auto DEFAULT_SRS_CONTROL_PORT = 6600

auto FEC_DAQ_RECEIVE_PORT = 6006

static int FEC_CONTROL_LOCAL_PORT = 6007

auto DEFAULT_DISPLAY_PERIOD = std::chrono::milliseconds{200}

auto DEFAULT_ROOT_HTTP_SERVER_PERIOD = std::chrono::milliseconds{1000}

auto FEC_ID_BIT_LENGTH = 8

auto HIT_DATA_BIT_LENGTH = 48

auto SRS_TIMESTAMP_HIGH_BIT_LENGTH = 32

auto SRS_TIMESTAMP_LOW_BIT_LENGTH = 10

auto FLAG_BIT_POSITION = 15

auto GZIP_DEFAULT_COMPRESSION_LEVEL = 9

auto PROTOBUF_ENABLE_GZIP = true

Common functions

group Common functions

Functions

template<std::size_t bit_size, std::size_t max, std::size_t min = 0>
std::bitset<max - min> subset(const std::bitset<bit_size> &bits)

template<std::size_t high_size, std::size_t low_size>
std::bitset<high_size + low_size> merge_bits(const std::bitset<high_size> &high_bits, const std::bitset<low_size> &low_bits)

template<std::size_t bit_size>
auto byte_swap(const std::bitset<bit_size> &bits)

template<typename T>
auto gray_to_binary(T gray_val)

auto get_shared_from_this(auto &&obj)

auto create_coro_future(auto &coro, auto &&pre_fut)

auto create_coro_future(auto &coro, bool is_terminated)

void coro_sync_start(auto &coro, auto&&... args)

Common aliases

group Common aliases

Typedefs

using io_context_type = asio::thread_pool

using BufferElementType = char

using BinaryData = std::vector<BufferElementType>

template<int buffer_size = common::SMALL_READ_MSG_BUFFER_SIZE>
using ReadBufferType = std::array<BufferElementType, buffer_size>

using CommunicateEntryType = uint32_t

Namespace

namespace reader

class ProtoMsg

#include <ProtoMsgReader.hpp>

Public Functions

ProtoMsg()

Constructor allocates the memeory for member variables

ProtoMsg(const ProtoMsg&) = delete

Deleted copy constructor.

ProtoMsg &operator=(const ProtoMsg&) = delete

Deleted copy assignment.

ProtoMsg(ProtoMsg&&) = default

Default move constructor.

ProtoMsg &operator=(ProtoMsg&&) = default

Default move assignment.

~ProtoMsg()

Default destructor.

void convert(std::string_view msg, StructData &struct_data)

Convert binary data to a struct (inout).

Parameters:

• msg – The input binary data.

• struct_data – The struct data to store the deserialized binary data.

const StructData &convert(std::string_view msg)

Convert binary data to a struct, owned by ProtoMsgReader.

Description.

Parameters:

msg – The input binary data.

Returns:

The const reference to the internal struct data.

Private Members

std::unique_ptr<process::Proto2StructConverter> proto_to_struct_converter_

A converter to transform Protobuf struct to native C++ struct.

std::unique_ptr<process::ProtoDeserializer> proto_deserializer_

A converter to transform binary data to Protobuf struct.

class RawFrame

#include <RawFrameReader.hpp>

Public Functions

explicit RawFrame() = default

Default Constructor. No memory allocation.

explicit RawFrame(const std::string &filename)

Constructor that opens a file with the given filename.

Parameters:

filename – The file name of the input binary

std::string_view read_one_frame()

Read one frame of the binary data from a file specified by the constructor RawFrame(conststd::string&).

The binary data frame is written to the internal member variable input_buffer_; srs::common::LARGE_READ_MSG_BUFFER_SIZE bytes of memory will be reserved for the vector.

Returns:

Non-owning binary data.

inline const auto &get_binary_data() const

Getter to the internal binary data used by the member function read_one_frame().

Public Static Functions

static std::size_t read_one_frame(std::vector<char> &binary_data, std::ifstream &input_file)

Read one frame of the bianry data to a vector.

The input vector is first reserved with srs::common::LARGE_READ_MSG_BUFFER_SIZE elements and then resized with the size value, which is read from the binary file in the beginning. The vector is then set with size bytes of data from the file.

Parameters:

• binary_data – The vector of chars to be filled.

• input_file – Input file handler.

Returns:

The amount of bytes read from the binary file. If the binary input file is not open, return 0.

Private Members

std::string input_filename_

Input binary file name.

std::ifstream input_file_

Input binary file handler.

std::vector<char> input_buffer_

internal binary data buffer

namespace workflow

class DataMonitor

#include <Handler.hpp>

Public Functions

explicit DataMonitor(Handler *processor, io_context_type *io_context)

inline void show_data_speed(bool val = true)

inline void set_display_period(std::chrono::milliseconds duration)

void start()

void stop()

inline void update(const StructData &data_struct)

void http_server_loop()

inline double get_received_bytes_MBps() const

inline double get_processed_hit_rate() const

Private Functions

void set_speed_string(double speed_MBps)

asio::awaitable<void> print_cycle()

Private Members

bool is_shown_ = true

gsl::not_null<Handler*> processor_

gsl::not_null<io_context_type*> io_context_

std::shared_ptr<spdlog::logger> console_

asio::steady_timer clock_

std::atomic<uint64_t> last_read_data_bytes_ = 0

std::atomic<uint64_t> last_processed_hit_num_ = 0

std::chrono::time_point<std::chrono::steady_clock> last_print_time_ = std::chrono::steady_clock::now()

std::chrono::milliseconds period_ = common::DEFAULT_DISPLAY_PERIOD

std::atomic<double> current_received_bytes_MBps_

std::atomic<double> current_hits_ps_

std::string speed_string_

class Handler

#include <Handler.hpp>

Public Functions

explicit Handler(App *control)

Handler(const Handler&) = delete

Handler(Handler&&) = delete

Handler &operator=(const Handler&) = delete

Handler &operator=(Handler&&) = delete

~Handler()

void read_data_once(std::span<BufferElementType> read_data)

inline void abort()

void start(bool is_blocking)

inline uint64_t get_read_data_bytes() const

inline uint64_t get_processed_hit_number() const

inline const auto &get_data_monitor() const

inline auto &get_app()

inline void set_print_mode(common::DataPrintMode mode)

inline void set_show_data_speed(bool val = true)

inline void set_monitor_display_period(std::chrono::milliseconds duration)

inline void set_output_filenames(const std::vector<std::string> &filenames)

void stop()

Private Functions

void analysis_loop(bool is_blocking)

void update_monitor()

void write_data()

void print_data()

void clear_data_buffer()

Private Members

std::atomic<bool> is_stopped_ = {false}

std::size_t received_data_size_ = {}

common::DataPrintMode print_mode_ = common::DataPrintMode::print_speed

std::atomic<uint64_t> total_read_data_bytes_ = 0

std::atomic<uint64_t> total_processed_hit_numer_ = 0

gsl::not_null<App*> app_

DataMonitor monitor_

tbb::concurrent_bounded_queue<process::SerializableMsgBuffer> data_queue_

TaskDiagram data_processes_

class TaskDiagram

#include <TaskDiagram.hpp>

Public Types

using StartingCoroType = asio::experimental::coro<std::string_view(bool)>

Public Functions

explicit TaskDiagram(Handler *data_processor, asio::thread_pool &thread_pool)

~TaskDiagram()

TaskDiagram(const TaskDiagram&) = delete

TaskDiagram(TaskDiagram&&) = delete

TaskDiagram &operator=(const TaskDiagram&) = delete

TaskDiagram &operator=(TaskDiagram&&) = delete

bool analysis_one(tbb::concurrent_bounded_queue<process::SerializableMsgBuffer> &data_queue, bool is_blocking)

void set_output_filenames(const std::vector<std::string> &filenames)

void reset()

template<process::DataConvertOptions option>
std::string_view get_data()

inline const auto &get_struct_data()

Private Functions

StartingCoroType generate_starting_coro(asio::any_io_executor)

std::expected<void, std::string_view> run_processes(bool is_stopped)

Private Members

process::SerializableMsgBuffer binary_data_

process::Raw2DelimRawConverter raw_to_delim_raw_converter_

process::StructDeserializer struct_deserializer_

process::Struct2ProtoConverter struct_proto_converter_

process::ProtoSerializer proto_serializer_

process::ProtoDelimSerializer proto_delim_serializer_

StartingCoroType coro_

writer::Manager writers_

namespace process

Enums

enum class DataConvertOptions : uint8_t

Values:

enumerator none

enumerator raw

enumerator raw_frame

enumerator structure

enumerator proto

enumerator proto_frame

Functions

std::string_view convert_option_to_string(DataConvertOptions option)

bool convert_option_has_dependency(DataConvertOptions dependee, DataConvertOptions depender)

Variables

auto EMPTY_CONVERT_OPTION_COUNT_MAP = [](){using enumDataConvertOptions;return std::array{ std::make_pair(raw, 0),std::make_pair(raw_frame, 0),std::make_pair(structure, 0),std::make_pair(proto, 0),std::make_pair(proto_frame, 0) };}()

auto CONVERT_OPTION_RELATIONS = [](){using enumDataConvertOptions;return std::array{ConvertOptionRelation{ raw, raw_frame },                            ConvertOptionRelation{ raw, structure },                            ConvertOptionRelation{ structure, proto },                            ConvertOptionRelation{ structure, proto_frame} };}()

const auto protobuf_delim_deserializer_converter = [](const proto::Data& proto_data,std::string& output_data) -> int{namespace protobuf = google::protobuf;namespace io = protobuf::io;auto output_stream = io::StringOutputStream{ &output_data };if constexpr (common::PROTOBUF_ENABLE_GZIP){auto option = io::GzipOutputStream::Options{};option.compression_level =common::GZIP_DEFAULT_COMPRESSION_LEVEL;auto gzip_output = io::GzipOutputStream{ &output_stream, option };protobuf::util::SerializeDelimitedToZeroCopyStream(proto_data, &gzip_output);gzip_output.Flush();}else{protobuf::util::SerializeDelimitedToZeroCopyStream(proto_data, &output_stream);}return 0;}

const auto protobuf_deserializer_converter = [](const proto::Data& proto_data, std::string& output_data) -> int{namespace protobuf = google::protobuf;namespace io = protobuf::io;auto output_stream = io::StringOutputStream{ &output_data };proto_data.SerializeToZeroCopyStream(&output_stream);return 0;}

struct ConvertOptionRelation

#include <DataConvertOptions.hpp>

Public Functions

inline constexpr ConvertOptionRelation(DataConvertOptions option, DataConvertOptions next_option)

Public Members

DataConvertOptions dependee

DataConvertOptions depender

template<typename Input, typename Output>
class DataConverterBase

#include <DataConverterBase.hpp>

Public Types

using InputType = Input

using OutputType = Output

using InputFuture = boost::shared_future<std::optional<InputType>>

using OutputFuture = boost::shared_future<std::optional<OutputType>>

using CoroType = asio::experimental::coro<OutputType(std::optional<InputType>)>

Public Functions

inline explicit DataConverterBase(auto coro)

inline OutputFuture create_future (this auto &&self, InputFuture &pre_fut, writer::Manager &writers)

Private Members

CoroType coro_

class Proto2StructConverter

#include <ProtoToStructConverter.hpp>

Public Functions

Proto2StructConverter() = default

inline const StructData &convert(const proto::Data &proto)

Public Static Functions

static inline void convert(const proto::Data &proto, StructData &struct_data)

Private Members

StructData data_

Private Static Functions

static inline void set_header(const proto::Data &proto, StructData &struct_data)

static inline void set_marker_data(const proto::Data &proto, StructData &struct_data)

static inline void set_hit_data(const proto::Data &proto, StructData &struct_data)

class ProtoDelimSerializer : public srs::process::ProtoSerializerBase<decltype(protobuf_delim_deserializer_converter)>

#include <ProtoDelimSerializer.hpp>

Public Functions

inline explicit ProtoDelimSerializer(asio::thread_pool &thread_pool)

Public Static Attributes

static auto ConverterOption = std::array{proto_frame}

class ProtoDeserializer

#include <ProtoDeserializer.hpp>

Public Functions

ProtoDeserializer() = default

inline const proto::Data &convert(std::string_view str_data)

Public Static Functions

static inline void convert(std::string_view data, proto::Data &proto)

Private Members

proto::Data data_

class ProtoSerializer : public srs::process::ProtoSerializerBase<decltype(protobuf_deserializer_converter)>

#include <ProtoSerializer.hpp>

Public Functions

inline explicit ProtoSerializer(asio::thread_pool &thread_pool)

Public Static Attributes

static auto ConverterOption = std::array{proto}

template<typename Converter>
class ProtoSerializerBase : public srs::process::DataConverterBase<const proto::Data*, std::string_view>

#include <ProtoSerializerBase.hpp>

Public Functions

inline explicit ProtoSerializerBase(asio::thread_pool &thread_pool, std::string name, Converter converter)

inline std::string_view data() const

Private Functions

inline void reset()

inline CoroType generate_coro(asio::any_io_executor)

Private Members

std::string name_

std::string output_data_

Converter converter_

class Raw2DelimRawConverter : public srs::process::DataConverterBase<std::string_view, std::string_view>

#include <RawToDelimRawConveter.hpp>

Public Types

using SizeType = common::RawDelimSizeType

Public Functions

inline explicit Raw2DelimRawConverter(asio::thread_pool &thread_pool)

inline OutputType data() const

Public Static Attributes

static auto ConverterOption = std::array{raw_frame}

Private Functions

inline CoroType generate_coro(asio::any_io_executor)

Private Members

std::vector<char> output_data_

Private Static Functions

static inline void convert(std::string_view input, std::vector<char> &output)

class SerializableMsgBuffer

#include <SerializableBuffer.hpp>

Public Functions

SerializableMsgBuffer() = default

inline explicit SerializableMsgBuffer(std::span<BufferElementType> read_data)

inline auto serialize(auto&&... structs)

inline std::string_view data() const

inline void clear()

Private Members

BinaryData data_

class Struct2ProtoConverter : public srs::process::DataConverterBase<const StructData*, const proto::Data*>

#include <StructToProtoConverter.hpp>

Public Functions

inline explicit Struct2ProtoConverter(asio::thread_pool &thread_pool)

inline const auto &data() const

Public Static Attributes

static auto ConverterOption = std::array{proto, proto_frame}

Private Functions

inline void reset()

inline const proto::Data &convert(const StructData &struct_data)

inline CoroType generate_coro(asio::any_io_executor)

inline void set_header(const StructData &struct_data)

inline void set_marker_data(const StructData &struct_data)

inline void set_hit_data(const StructData &struct_data)

Private Members

proto::Data output_data_

class StructDeserializer : public srs::process::DataConverterBase<std::string_view, const StructData*>

#include <StructDeserializer.hpp>

Public Types

using DataElementType = std::bitset<common::HIT_DATA_BIT_LENGTH>

using ReceiveDataSquence = std::vector<DataElementType>

Public Functions

inline explicit StructDeserializer(asio::thread_pool &thread_pool)

inline const auto &data() const

Public Static Attributes

static auto ConverterOption = std::array{structure}

Private Functions

inline void reset()

CoroType generate_coro(asio::any_io_executor)

std::size_t convert(std::string_view binary_data)

void translate_raw_data(StructData &struct_data)

void byte_reverse_data_sq()

Private Members

ReceiveDataSquence receive_raw_data_

StructData output_data_

Private Static Functions

static inline bool check_is_hit(const DataElementType &element)