Program Listing for File config.hpp

↰ Return to documentation for file (config/config.hpp)

#ifndef FELIX_STAR_CONFIG_H_
#define FELIX_STAR_CONFIG_H_

#include <map>
#include <vector>
#include <string>
#include <iostream>
#include <iterator>
#include <sstream>
#include <algorithm>

#include "ers/ers.h"
#include "block.hpp"                    //for MAX_BUF_CHUNK_SIZE
#include "felix/felix_fid.h"
#include "felix/FelixClientUtility.hpp"  //ip-iface conversion

#include "docopt/docopt.h"

ERS_DECLARE_ISSUE(felix_log, InvalidConfig, message, ((const std::string&)message))

enum class MonitoringType {
    FIFO,
    Prometheus,
    WebIS
};

enum class NetworkMode {
    rdma,
    tcp,
};

struct NetworkConfig
{
    std::string ip{"127.0.0.1"};
    std::map<int, uint16_t> ports;
    bool daq_unbuffered{false};
    unsigned netio_pages{256};
    uint32_t netio_pagesize{65536};
    unsigned long netio_timeout{0};
    bool daq_send_blocks{false};

    std::string dcs_ip{""};
    std::map<int, uint16_t> dcs_ports;
    bool dcs_unbuffered{true};
    unsigned dcs_netio_pages{128};
    uint32_t dcs_netio_pagesize{6144};
    unsigned long dcs_netio_timeout{10000};
    bool dcs_send_blocks{false};

    std::map<int, uint16_t> ttc_ports;
    unsigned ttc_netio_pages{64};
    uint32_t ttc_netio_pagesize{1536};
    unsigned long ttc_netio_timeout{1000};
    bool ttc_send_blocks{false};

    std::string bus_dir{""};
    std::string bus_groupname{"FELIX"};
    bool verbose_bus{false};

    NetworkMode daq_network_mode{NetworkMode::rdma};
    NetworkMode dcs_network_mode{NetworkMode::tcp};
};


struct ResourceConfig
{
    std::vector<uint16_t> device;
    std::vector<uint16_t> cid;
    std::vector<int> dma_ids;
    uint8_t vid{1};
    uint16_t did{0};
    size_t cmem_buffersize{1024*1024*1024};
    bool free_previous_cmem{true};
    bool toflx{false};
    bool use_file{false};
};


struct MonitoringConfig
{
    std::string monitoring_fifo{""};
    int monitoring_period_ms{1000};
    int prometheus_port{-1};
    std::vector<MonitoringType> local_monitoring_types{};

    static std::string printType(const MonitoringType type) {
        switch (type) {
            case MonitoringType::FIFO: return "FIFO";
            case MonitoringType::Prometheus: return "Prometheus";
            case MonitoringType::WebIS: return "WebIS";
            default: return "Unknown";
        }
    }
};


ERS_DECLARE_ISSUE(felix_log, config_issue, issue_message, ((const std::string&)issue_message))
class Config
{
    public:
        Config();
        virtual ~Config();
        virtual void parse(int argc, char **argv);
        virtual std::ostream& format(std::ostream& os) const;
        friend std::ostream& operator<<(std::ostream& os, const Config& c);
        int get_number_devices();
        uint16_t get_device_cid(unsigned int dev_no);
        int get_unique_dmaid(int dmaid, uint16_t device);
        int udmaid_to_deviceid(int udmaid);
        int udmaid_to_dmaid(int udmaid);

    protected:
        virtual std::string usage() { return "undefined"; } // = 0; FIXME, can only be added if we do not instantiate Config, needs to be reference (statistics, register)
        virtual std::string options();
        virtual std::string bugs();
        virtual void handle_cmd_line(std::map<std::string, docopt::value> args);

    public:
        bool verbose{false};
        std::string appname{""};
        ResourceConfig resource;
        MonitoringConfig stats;
        NetworkConfig network;

        // derived for easy class check
        bool use_file{false};
        bool vmem{false};

    private:
        [[nodiscard]] static std::string network_mode_to_str(NetworkMode type);
        [[nodiscard]] static NetworkMode network_mode_from_str(std::string_view type);
};


class ConfigFile : public virtual Config
{
    public:
        ConfigFile();
        virtual ~ConfigFile();
        virtual std::ostream& format(std::ostream& os) const override;
        friend std::ostream& operator<<(std::ostream& os, const ConfigFile& c);

    protected:
        virtual std::string options() override;
        virtual void handle_cmd_line(std::map<std::string, docopt::value> args) override;

    public:
        u_int    firmware{0};
        u_int    lock_mask{0};
        u_int    regmap{0};
        u_int    channels{24};
        u_int    block_size{1024};
        int      fromHostDataFormat{0};
        int      toHostDataFormat{0};
        bool     wide_mode{0};
        int      toflx_dmaid{-1};
        int      max_tlp_bytes{256};
        uint32_t status_leds{0};
        bool     fifo_as_file{false};
        std::string file{""};
        std::map<int, std::vector<uint16_t>> elinks;
        std::map<int, std::vector<uint16_t>> elinks_with_streams;
};


class ConfigToHost : public virtual Config {
    public:
        ConfigToHost();
        virtual std::ostream& format(std::ostream& os) const override;
        friend std::ostream& operator<<(std::ostream& os, const ConfigToHost& c);

    protected:
        virtual std::string usage() override;
        virtual std::string options() override;
        virtual void handle_cmd_line(std::map<std::string, docopt::value> args) override;
        void validate_config();

    public:
        unsigned int daq_threads{1};
        int dcs_rate_limit{-1};
        int l1id_check{-1};
        uint32_t max_dcs_chunk_size{UINT32_MAX};
        uint32_t max_daq_chunk_size{UINT32_MAX};
        int poll_time{10000};
};


class ConfigToFlx : public virtual Config {
    public:
        ConfigToFlx();
        virtual std::ostream& format(std::ostream& os) const override;
        friend std::ostream& operator<<(std::ostream& os, const ConfigToFlx& c);

    protected:
        virtual std::string usage() override;
        virtual std::string options() override;
        virtual void handle_cmd_line(std::map<std::string, docopt::value> args) override;

    public:
        bool unbuffered{false};
};


class ConfigFileToHost : public ConfigToHost, public ConfigFile {
    public:
        ConfigFileToHost();
        virtual ~ConfigFileToHost();
        virtual std::ostream& format(std::ostream& os) const override;
        friend std::ostream& operator<<(std::ostream& os, const ConfigFileToHost& c);

    protected:
        virtual std::string usage() override;
        virtual std::string options() override;
        virtual void handle_cmd_line(std::map<std::string, docopt::value> args) override;

    public:
        // alphabetical
        unsigned block_rate{0};
        bool full_mode{false};
        bool repeat{true};
};


class ConfigToFlxToFile : public ConfigToFlx, public ConfigFile {
    public:
        ConfigToFlxToFile();
        virtual ~ConfigToFlxToFile();
        virtual std::ostream& format(std::ostream& os) const override;
        friend std::ostream& operator<<(std::ostream& os, const ConfigToFlxToFile& c);

    protected:
        virtual std::string usage() override;
        virtual std::string options() override;
        virtual void handle_cmd_line(std::map<std::string, docopt::value> args) override;
};

class ConfigTrickle : public virtual Config {
    public:
        ConfigTrickle();
        virtual std::ostream& format(std::ostream& os) const override;
        friend std::ostream& operator<<(std::ostream& os, const ConfigTrickle& c);

    protected:
        virtual std::string usage() override;
        virtual std::string options() override;
        virtual void handle_cmd_line(std::map<std::string, docopt::value> args) override;

    public:
        bool unbuffered{false};
        bool trickle{false};
};

class ConfigTrickleToFile : public ConfigTrickle, public ConfigFile {
    public:
        ConfigTrickleToFile();
        virtual ~ConfigTrickleToFile();
        virtual std::ostream& format(std::ostream& os) const override;
        friend std::ostream& operator<<(std::ostream& os, const ConfigTrickleToFile& c);

    protected:
        virtual std::string usage() override;
        virtual std::string options() override;
        virtual void handle_cmd_line(std::map<std::string, docopt::value> args) override;
};

#endif /* FELIX_STAR_CONFIG_H_ */