Line data Source code
1 : /**
2 : * @file TimingHardwareManagerBase.hpp
3 : *
4 : * TimingHardwareManagerBase is a DAQModule implementation that
5 : * provides the interface to the timing system hardware.
6 : *
7 : * This is part of the DUNE DAQ Software Suite, copyright 2020.
8 : * Licensing/copyright details are in the COPYING file that you should have
9 : * received with this code.
10 : */
11 :
12 : #ifndef TIMINGLIBS_SRC_TIMINGHARDWAREMANAGER_HPP_
13 : #define TIMINGLIBS_SRC_TIMINGHARDWAREMANAGER_HPP_
14 :
15 : #include "InfoGatherer.hpp"
16 : #include "timinglibs/TimingHardwareInterface.hpp"
17 : #include "timinglibs/TimingIssues.hpp"
18 : #include "timinglibs/timingcmd/Nljs.hpp"
19 : #include "timinglibs/timingcmd/Structs.hpp"
20 : #include "timinglibs/timingcmd/msgp.hpp"
21 :
22 : #include "appfwk/DAQModule.hpp"
23 : #include "ers/Issue.hpp"
24 : #include "iomanager/Receiver.hpp"
25 : #include "logging/Logging.hpp"
26 :
27 : #include "confmodel/Connection.hpp"
28 : #include "timinglibs/dal/TimingHardwareManagerConf.hpp"
29 :
30 : #include "timing/EndpointDesignInterface.hpp"
31 : #include "timing/HSIDesignInterface.hpp"
32 : #include "timing/MasterDesignInterface.hpp"
33 : #include "timing/TimingNode.hpp"
34 : #include "timing/TopDesignInterface.hpp"
35 :
36 : #include "uhal/ConnectionManager.hpp"
37 : #include "utilities/ReusableThread.hpp"
38 :
39 : #include <map>
40 : #include <memory>
41 : #include <regex>
42 : #include <string>
43 : #include <vector>
44 :
45 : namespace dunedaq {
46 : namespace timinglibs {
47 :
48 : /**
49 : * @brief TimingHardwareManagerBase creates vectors of ints and writes
50 : * them to the configured output queues.
51 : */
52 : class TimingHardwareManagerBase
53 : : public dunedaq::appfwk::DAQModule
54 : , public timinglibs::TimingHardwareInterface
55 : {
56 : public:
57 : /**
58 : * @brief TimingHardwareManagerBase Constructor
59 : * @param name Instance name for this TimingHardwareManagerBase instance
60 : */
61 : explicit TimingHardwareManagerBase(const std::string& name);
62 :
63 : TimingHardwareManagerBase(const TimingHardwareManagerBase&) =
64 : delete; ///< TimingHardwareManagerBase is not copy-constructible
65 : TimingHardwareManagerBase& operator=(const TimingHardwareManagerBase&) =
66 : delete; ///< TimingHardwareManagerBase is not copy-assignable
67 : TimingHardwareManagerBase(TimingHardwareManagerBase&&) =
68 : delete; ///< TimingHardwareManagerBase is not move-constructible
69 : TimingHardwareManagerBase& operator=(TimingHardwareManagerBase&&) =
70 : delete; ///< TimingHardwareManagerBase is not move-assignable
71 0 : virtual ~TimingHardwareManagerBase() {}
72 :
73 : void init(std::shared_ptr<appfwk::ConfigurationManager> mcfg) override;
74 : virtual void conf(const CommandData_t& data);
75 :
76 : protected:
77 : // Commands
78 : // virtual void do_configure(const CommandData_t&);
79 : // virtual void do_start(const CommandData_t&);
80 : // virtual void do_stop(const CommandData_t&);
81 : virtual void do_scrap(const CommandData_t&);
82 :
83 : virtual void process_hardware_command(timingcmd::TimingHwCmd& timing_hw_cmd);
84 :
85 : // Configuration
86 : std::string m_hw_cmd_connection;
87 : using source_t = dunedaq::iomanager::ReceiverConcept<timingcmd::TimingHwCmd>;
88 : std::shared_ptr<source_t> m_hw_command_receiver;
89 :
90 : // hardware polling intervals [us]
91 : // TODO change to duration::milliseconds
92 : uint m_gather_interval;
93 : uint m_gather_interval_debug;
94 :
95 : // uhal members
96 : std::map<std::string, std::unique_ptr<uhal::HwInterface>> m_hw_device_map;
97 : std::mutex m_hw_device_map_mutex;
98 :
99 : // managed timing devices
100 : std::string m_monitored_device_name_master;
101 : std::map<uint, std::string> m_monitored_device_names_fanout;
102 : std::string m_monitored_device_name_endpoint;
103 : std::string m_monitored_device_name_hsi;
104 :
105 : virtual void register_common_hw_commands_for_design() = 0;
106 : virtual void register_master_hw_commands_for_design() = 0;
107 : virtual void register_endpoint_hw_commands_for_design() = 0;
108 : virtual void register_hsi_hw_commands_for_design() = 0;
109 :
110 : // retrieve top level/design object for a timing device
111 : template<class TIMING_DEV>
112 : TIMING_DEV get_timing_device(const std::string& device_name);
113 : const timing::TimingNode* get_timing_device_plain(const std::string& device_name);
114 :
115 : // timing hw cmds stuff
116 : std::map<timingcmd::TimingHwCmdId, std::function<void(const timingcmd::TimingHwCmd&)>> m_timing_hw_cmd_map_;
117 :
118 : template<typename Child>
119 : void register_timing_hw_command(const std::string& hw_cmd_id, void (Child::*f)(const timingcmd::TimingHwCmd&));
120 :
121 : // timing common commands
122 : void io_reset(const timingcmd::TimingHwCmd& hw_cmd);
123 : void print_status(const timingcmd::TimingHwCmd& hw_cmd);
124 :
125 : // timing master commands
126 : void set_timestamp(const timingcmd::TimingHwCmd& hw_cmd);
127 : void set_endpoint_delay(const timingcmd::TimingHwCmd& hw_cmd);
128 : void send_fl_cmd(const timingcmd::TimingHwCmd& hw_cmd);
129 : void master_endpoint_scan(const timingcmd::TimingHwCmd& hw_cmd);
130 :
131 : // timing partition commands
132 : virtual void partition_configure(const timingcmd::TimingHwCmd& hw_cmd) = 0;
133 :
134 : // timing endpoint commands
135 : void endpoint_enable(const timingcmd::TimingHwCmd& hw_cmd);
136 : void endpoint_disable(const timingcmd::TimingHwCmd& hw_cmd);
137 : void endpoint_reset(const timingcmd::TimingHwCmd& hw_cmd);
138 :
139 : // hsi
140 : void hsi_reset(const timingcmd::TimingHwCmd& hw_cmd);
141 : void hsi_configure(const timingcmd::TimingHwCmd& hw_cmd);
142 : void hsi_start(const timingcmd::TimingHwCmd& hw_cmd);
143 : void hsi_stop(const timingcmd::TimingHwCmd& hw_cmd);
144 : void hsi_print_status(const timingcmd::TimingHwCmd& hw_cmd);
145 :
146 : // opmon stuff
147 : std::atomic<uint64_t> m_received_hw_commands_counter; // NOLINT(build/unsigned)
148 : std::atomic<uint64_t> m_accepted_hw_commands_counter; // NOLINT(build/unsigned)
149 : std::atomic<uint64_t> m_rejected_hw_commands_counter; // NOLINT(build/unsigned)
150 : std::atomic<uint64_t> m_failed_hw_commands_counter; // NOLINT(build/unsigned)
151 :
152 : // monitoring
153 : std::map<std::string, std::unique_ptr<InfoGatherer>> m_info_gatherers;
154 :
155 : void register_info_gatherer(uint gather_interval, const std::string& device_name, int op_mon_level);
156 : void gather_monitor_data(InfoGatherer& gatherer);
157 :
158 : virtual void start_hw_mon_gathering(const std::string& device_name = "");
159 : virtual void stop_hw_mon_gathering(const std::string& device_name = "");
160 : virtual std::vector<std::string> check_hw_mon_gatherer_is_running(const std::string& device_name);
161 :
162 : std::mutex m_command_threads_map_mutex;
163 : std::map<std::string, std::unique_ptr<std::thread>> m_command_threads;
164 : std::mutex master_sfp_mutex;
165 : virtual void perform_endpoint_scan(const timingcmd::TimingHwCmd& hw_cmd);
166 : virtual void clean_endpoint_scan_threads();
167 : std::unique_ptr<dunedaq::utilities::ReusableThread> m_endpoint_scan_threads_clean_up_thread;
168 : std::atomic<bool> m_run_endpoint_scan_cleanup_thread;
169 : const timinglibs::dal::TimingHardwareManagerConf* m_params;
170 : std::map<uint, int> m_monitored_endpoints_round_trip_times;
171 : };
172 :
173 : } // namespace timinglibs
174 : } // namespace dunedaq
175 :
176 : #include "detail/TimingHardwareManagerBase.hxx"
177 :
178 : #endif // TIMINGLIBS_SRC_TIMINGHARDWAREMANAGER_HPP_
179 :
180 : // Local Variables:
181 : // c-basic-offset: 2
182 : // End:
|
