00001 #ifndef ARTDAQ_DAQRATE_DATATRANSFERMANAGER_HH
00002 #define ARTDAQ_DAQRATE_DATATRANSFERMANAGER_HH
00003
00004 #include <map>
00005 #include <set>
00006 #include <memory>
00007 #include <condition_variable>
00008
00009 #include "fhiclcpp/fwd.h"
00010
00011 #include "artdaq-core/Data/Fragment.hh"
00012 #include "artdaq/TransferPlugins/TransferInterface.hh"
00013 #include "artdaq/DAQrate/detail/FragCounter.hh"
00014 #include "artdaq-utilities/Plugins/MetricManager.hh"
00015 #include "artdaq/DAQrate/SharedMemoryEventManager.hh"
00016
00017 namespace artdaq
00018 {
00019 class DataReceiverManager;
00020 }
00021
00027 class artdaq::DataReceiverManager
00028 {
00029 public:
00030
00046 explicit DataReceiverManager(const fhicl::ParameterSet& ps, std::shared_ptr<SharedMemoryEventManager> shm);
00047
00051 virtual ~DataReceiverManager();
00052
00057 size_t count() const;
00058
00064 size_t slotCount(size_t rank) const;
00065
00070 size_t byteCount() const;
00071
00075 void start_threads();
00076
00080 void stop_threads();
00081
00086 std::set<int> enabled_sources() const;
00087
00092 std::set<int> running_sources() const;
00093
00098 std::shared_ptr<SharedMemoryEventManager> getSharedMemoryEventManager() const { return shm_manager_; }
00099
00100
00105 std::shared_ptr<detail::FragCounter> GetReceivedFragmentCount() { return std::shared_ptr<detail::FragCounter>(&recv_frag_count_); }
00106
00107 private:
00108 void runReceiver_(int);
00109
00110 std::atomic<bool> stop_requested_;
00111 std::atomic<size_t> stop_requested_time_;
00112
00113 std::map<int, boost::thread> source_threads_;
00114 std::map<int, std::unique_ptr<TransferInterface>> source_plugins_;
00115
00116 struct source_metric_data
00117 {
00118 source_metric_data() : delta_t(0), hdr_delta_t(0), store_delta_t(0), data_delta_t(0),dead_t(0), data_point_count(0), data_size(0), header_size(0) {}
00119 double delta_t;
00120 double hdr_delta_t;
00121 double store_delta_t;
00122 double data_delta_t;
00123 double dead_t;
00124 size_t data_point_count;
00125 size_t data_size;
00126 size_t header_size;
00127 };
00128
00129 std::unordered_map<int, source_metric_data> source_metric_data_;
00130 std::unordered_map<int, std::chrono::steady_clock::time_point> source_metric_send_time_;
00131 std::unordered_map<int, std::atomic<bool>> enabled_sources_;
00132 std::unordered_map<int, std::atomic<bool>> running_sources_;
00133
00134 detail::FragCounter recv_frag_count_;
00135 detail::FragCounter recv_frag_size_;
00136 detail::FragCounter recv_seq_count_;
00137
00138 size_t receive_timeout_;
00139 size_t stop_timeout_ms_;
00140 std::shared_ptr<SharedMemoryEventManager> shm_manager_;
00141
00142 bool non_reliable_mode_enabled_;
00143 size_t non_reliable_mode_retry_count_;
00144 };
00145
00146 inline
00147 size_t
00148 artdaq::DataReceiverManager::
00149 count() const
00150 {
00151 return recv_frag_count_.count();
00152 }
00153
00154 inline
00155 size_t
00156 artdaq::DataReceiverManager::
00157 slotCount(size_t rank) const
00158 {
00159 return recv_frag_count_.slotCount(rank);
00160 }
00161
00162 inline
00163 size_t
00164 artdaq::DataReceiverManager::
00165 byteCount() const
00166 {
00167 return recv_frag_size_.count();
00168 }
00169 #endif //ARTDAQ_DAQRATE_DATATRANSFERMANAGER_HH